#include <gmlib/number/uint256.h>

#include <stdexcept>
#include <cstring>

using namespace number;

void test_uint256_div_uint32()
{
    uint256_t     dividend, quotient;
    std::uint32_t remainder;
    std::uint8_t  quotient_data[32];

    static std::uint8_t  dividend0[32] = {0x09,0x99,0x50,0xd8,0x36,0xf6,0x75,0xcc,0x81,0xe7,0x4e,0xf5,0xe8,0xe2,0x5d,0x94,0x0e,0xd9,0x04,0x75,0x95,0x31,0x98,0x5d,0x5d,0x9d,0xc9,0xf8,0x18,0x18,0xe8,0x11};
    static std::uint32_t divisor0     = 1862494043;
    static std::uint8_t  quotient0[32]    = {0x00,0x00,0x00,0x00,0x16,0x22,0xa4,0xe7,0xb9,0xd9,0xc8,0xe0,0xc8,0xb8,0xc2,0x09,0x1b,0xc0,0x59,0xc3,0x75,0xc6,0x8a,0xfe,0x2b,0x2a,0x7a,0x94,0xbe,0x29,0xd6,0xb4};
    static std::uint32_t remainder0      = 431696405;
    uint256_from_bytes(dividend, dividend0);
    remainder = uint256_div_uint32(quotient, dividend, divisor0);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient0, quotient_data, 32) != 0 || remainder0 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend1[32] = {0xdb,0xc4,0x96,0xcb,0x8e,0x81,0x97,0x3e,0x0b,0xec,0xd7,0xb0,0x38,0x98,0xd1,0x90,0xf9,0xeb,0xda,0xcc,0x0c,0xb1,0xe2,0x9c,0x65,0x8c,0xda,0x14,0x95,0xe6,0x0a,0xf5};
    static std::uint32_t divisor1     = 1243862423;
    static std::uint8_t  quotient1[32]    = {0x00,0x00,0x00,0x02,0xf6,0xd7,0xc2,0x4f,0x21,0xbc,0xa1,0x95,0x22,0x02,0xc5,0x59,0x81,0xd0,0x3b,0xd2,0xec,0xea,0x23,0x77,0xdc,0x56,0xdf,0xd8,0x5f,0x10,0x95,0x12};
    static std::uint32_t remainder1      = 564142935;
    uint256_from_bytes(dividend, dividend1);
    remainder = uint256_div_uint32(quotient, dividend, divisor1);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient1, quotient_data, 32) != 0 || remainder1 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend2[32] = {0x5c,0x90,0xa9,0x58,0x74,0x03,0xe4,0x30,0xec,0x66,0xa7,0x87,0x95,0xe7,0x61,0xd1,0x77,0x31,0xaf,0x10,0x50,0x6b,0xf2,0xef,0xc6,0xf8,0x77,0x18,0x6d,0x76,0xb0,0x7e};
    static std::uint32_t divisor2     = 1066984056;
    static std::uint8_t  quotient2[32]    = {0x00,0x00,0x00,0x01,0x74,0x9a,0xfa,0xbb,0x58,0x83,0xb6,0xf5,0xec,0x2e,0xf3,0x49,0x0b,0x2d,0x98,0xf0,0x69,0xe3,0x14,0x92,0x44,0xf4,0xc3,0xbb,0x8e,0x8c,0x31,0x27};
    static std::uint32_t remainder2      = 271792182;
    uint256_from_bytes(dividend, dividend2);
    remainder = uint256_div_uint32(quotient, dividend, divisor2);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient2, quotient_data, 32) != 0 || remainder2 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend3[32] = {0xfa,0xec,0xbd,0x38,0x9b,0xe4,0xbc,0xfc,0x49,0xb6,0x4a,0x08,0x72,0xe6,0xcc,0x3a,0xba,0xbc,0xed,0x20,0x57,0xee,0x05,0xcd,0xe0,0x09,0x02,0xc7,0x7e,0xbf,0xf2,0x06};
    static std::uint32_t divisor3     = 507088657;
    static std::uint8_t  quotient3[32]    = {0x00,0x00,0x00,0x08,0x4d,0x4b,0xda,0x7b,0x60,0xca,0xc0,0xb0,0xa4,0x8a,0x1f,0x0c,0x6b,0xb1,0xa8,0x07,0xe9,0x1d,0x65,0x08,0x17,0x62,0xdf,0x7a,0x50,0x3b,0x95,0xf3};
    static std::uint32_t remainder3      = 82657251;
    uint256_from_bytes(dividend, dividend3);
    remainder = uint256_div_uint32(quotient, dividend, divisor3);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient3, quotient_data, 32) != 0 || remainder3 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend4[32] = {0x7d,0x2c,0xaf,0x82,0xee,0xea,0xcb,0xe2,0x26,0xe8,0x75,0x55,0x57,0x90,0xf8,0x2e,0xc1,0xd3,0xfc,0xff,0x2a,0x3a,0xf4,0xd4,0x6b,0x0a,0x18,0xe8,0x83,0x0e,0x07,0xbc};
    static std::uint32_t divisor4     = 168393880;
    static std::uint8_t  quotient4[32]    = {0x00,0x00,0x00,0x0c,0x78,0xa3,0x31,0x8d,0x34,0x9c,0xe7,0x7a,0x3b,0x92,0x60,0x2b,0x41,0x5c,0xa8,0x83,0xa7,0xed,0x03,0xf3,0x9a,0x38,0x26,0xd4,0x24,0xb3,0x16,0x6b};
    static std::uint32_t remainder4      = 35251252;
    uint256_from_bytes(dividend, dividend4);
    remainder = uint256_div_uint32(quotient, dividend, divisor4);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient4, quotient_data, 32) != 0 || remainder4 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend5[32] = {0xcc,0x01,0x1c,0xdd,0x94,0x74,0x03,0x1b,0x7f,0x26,0x14,0x4b,0x98,0x28,0x9f,0xcd,0x59,0xa5,0x4a,0x7b,0xb1,0xfe,0xe0,0x8f,0x57,0x12,0x42,0x42,0x50,0x51,0xc1,0xcc};
    static std::uint32_t divisor5     = 295334610;
    static std::uint8_t  quotient5[32]    = {0x00,0x00,0x00,0x0b,0x96,0xc6,0xf8,0xcd,0x1e,0xd3,0x4b,0x74,0x5d,0xa6,0x12,0x91,0x4f,0x02,0x5a,0x6a,0xe4,0x22,0x62,0x3e,0x62,0x16,0x98,0x4e,0x37,0x22,0xf8,0x96};
    static std::uint32_t remainder5      = 45288128;
    uint256_from_bytes(dividend, dividend5);
    remainder = uint256_div_uint32(quotient, dividend, divisor5);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient5, quotient_data, 32) != 0 || remainder5 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend6[32] = {0x10,0xa3,0xd6,0xb2,0xaa,0x05,0xe1,0x1a,0xb2,0x71,0x59,0x45,0x79,0x5e,0x82,0x29,0x45,0x1a,0xbd,0x81,0xf1,0xd6,0x9e,0xd6,0x17,0xf5,0xe8,0x37,0xd7,0x08,0x20,0xfe};
    static std::uint32_t divisor6     = 3140305424;
    static std::uint8_t  quotient6[32]    = {0x00,0x00,0x00,0x00,0x16,0xc2,0x24,0x8c,0xae,0xde,0x93,0xfd,0xc4,0xd1,0x8f,0x83,0x4f,0xa9,0x51,0xaa,0x24,0x5c,0x3d,0xfe,0x9f,0x41,0xdb,0x6e,0x53,0x57,0xc0,0x38};
    static std::uint32_t remainder6      = 1344646526;
    uint256_from_bytes(dividend, dividend6);
    remainder = uint256_div_uint32(quotient, dividend, divisor6);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient6, quotient_data, 32) != 0 || remainder6 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend7[32] = {0x72,0x15,0x83,0x70,0xd2,0x69,0xa9,0xa5,0xae,0x65,0x8f,0x33,0xfe,0x3b,0x89,0x0b,0x93,0xf4,0x48,0xb3,0xa5,0xaa,0x3c,0x81,0x4f,0x42,0x6d,0xcb,0xb3,0x94,0xfb,0x36};
    static std::uint32_t divisor7     = 3077892947;
    static std::uint8_t  quotient7[32]    = {0x00,0x00,0x00,0x00,0x9f,0x32,0x16,0xf3,0x2b,0x40,0xe9,0x2e,0xbd,0x04,0xc2,0xfa,0x63,0xab,0x18,0xf6,0x0e,0x17,0xb0,0x9e,0x7f,0x59,0x36,0x43,0xe6,0x79,0xcd,0xaa};
    static std::uint32_t remainder7      = 1933852440;
    uint256_from_bytes(dividend, dividend7);
    remainder = uint256_div_uint32(quotient, dividend, divisor7);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient7, quotient_data, 32) != 0 || remainder7 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend8[32] = {0x5a,0xff,0xb2,0x29,0x76,0x31,0xa9,0x92,0xf0,0xce,0x58,0x35,0x05,0xc6,0xaf,0x07,0x58,0xd5,0x56,0x3d,0xab,0x2c,0xd3,0x1e,0xe3,0x15,0x12,0x88,0x62,0xc3,0x3a,0x4f};
    static std::uint32_t divisor8     = 2623879481;
    static std::uint8_t  quotient8[32]    = {0x00,0x00,0x00,0x00,0x94,0xf4,0x2e,0xd1,0x28,0xd4,0x9b,0xf2,0xd8,0x81,0xdb,0x66,0x4e,0x31,0x90,0xe0,0x65,0xc1,0x97,0x5f,0x7c,0x37,0x8d,0x98,0x9b,0xdc,0x04,0xff};
    static std::uint32_t remainder8      = 1427003016;
    uint256_from_bytes(dividend, dividend8);
    remainder = uint256_div_uint32(quotient, dividend, divisor8);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient8, quotient_data, 32) != 0 || remainder8 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend9[32] = {0xbd,0x05,0x61,0xe6,0x21,0x1c,0x70,0xcf,0x49,0x95,0x23,0x99,0xc4,0xaa,0xea,0xc1,0x37,0xdc,0x76,0xfb,0x0f,0x17,0xa3,0x00,0x7e,0x62,0xaa,0x0a,0x1d,0xf9,0xfd,0x78};
    static std::uint32_t divisor9     = 1708957521;
    static std::uint8_t  quotient9[32]    = {0x00,0x00,0x00,0x01,0xdb,0x0c,0xa0,0xb8,0xab,0x52,0xc7,0xcf,0xb8,0x78,0x14,0x8e,0x55,0x23,0x18,0x89,0xdf,0x21,0xc0,0x0b,0x4d,0x1d,0x5c,0x02,0x00,0x95,0x0f,0x12};
    static std::uint32_t remainder9      = 1291586246;
    uint256_from_bytes(dividend, dividend9);
    remainder = uint256_div_uint32(quotient, dividend, divisor9);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient9, quotient_data, 32) != 0 || remainder9 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend10[32] = {0x3b,0x12,0x87,0xff,0xf5,0x2d,0xdf,0x5d,0x61,0x64,0x99,0xc9,0xe2,0x5a,0x76,0x05,0xae,0xc6,0xf0,0x24,0x5b,0xd8,0x6d,0x40,0xfc,0x89,0x1b,0x4a,0x6a,0x50,0xdf,0x4d};
    static std::uint32_t divisor10     = 356416555;
    static std::uint8_t  quotient10[32]    = {0x00,0x00,0x00,0x02,0xc7,0xd8,0xc5,0xe1,0x1d,0x43,0x25,0xfc,0xd5,0x1a,0x21,0xc6,0x1f,0xf4,0xce,0xef,0x2a,0xaa,0xaa,0x4c,0x94,0x0a,0xab,0xdf,0x66,0x40,0x2d,0x0f};
    static std::uint32_t remainder10      = 51644872;
    uint256_from_bytes(dividend, dividend10);
    remainder = uint256_div_uint32(quotient, dividend, divisor10);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient10, quotient_data, 32) != 0 || remainder10 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend11[32] = {0x64,0xe5,0x0c,0xad,0x66,0x23,0x7a,0x04,0x65,0xe7,0xe4,0x23,0x64,0x72,0xf1,0xa3,0x8f,0x2c,0x6e,0xc8,0xcc,0x41,0x69,0xa3,0xae,0x3a,0x2b,0x7f,0xdf,0xe0,0x18,0x93};
    static std::uint32_t divisor11     = 2068124765;
    static std::uint8_t  quotient11[32]    = {0x00,0x00,0x00,0x00,0xd1,0x88,0x57,0xf5,0x6d,0x72,0x28,0xaa,0x2a,0x71,0x30,0xe6,0xeb,0xbe,0xa4,0x50,0x9e,0xe8,0x4b,0xe7,0xfc,0xb0,0x17,0x39,0xff,0x9a,0xa8,0x1e};
    static std::uint32_t remainder11      = 897101229;
    uint256_from_bytes(dividend, dividend11);
    remainder = uint256_div_uint32(quotient, dividend, divisor11);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient11, quotient_data, 32) != 0 || remainder11 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend12[32] = {0x70,0xcc,0xec,0x31,0x35,0x71,0x81,0x0a,0xfc,0x13,0x2d,0x0d,0x11,0x3d,0xb1,0x7d,0x30,0xcb,0xc9,0x7d,0x0f,0xef,0x79,0x28,0x66,0x83,0x68,0x86,0xa2,0x60,0xcd,0x0b};
    static std::uint32_t divisor12     = 472138490;
    static std::uint8_t  quotient12[32]    = {0x00,0x00,0x00,0x04,0x02,0x20,0xae,0xee,0xac,0x75,0xd1,0xab,0x08,0x53,0xb7,0xd6,0xda,0x49,0xd2,0x68,0x35,0x12,0x1f,0xee,0x5f,0xd5,0x8e,0xea,0x93,0x73,0x78,0xa3};
    static std::uint32_t remainder12      = 328660957;
    uint256_from_bytes(dividend, dividend12);
    remainder = uint256_div_uint32(quotient, dividend, divisor12);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient12, quotient_data, 32) != 0 || remainder12 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend13[32] = {0x89,0x5f,0xd7,0xb3,0x26,0xb9,0x4c,0x7f,0x91,0x18,0xbb,0x16,0x00,0x0f,0x49,0xc8,0x1a,0x35,0x8c,0xa0,0x0d,0x75,0x98,0x5d,0x99,0xc9,0x43,0x09,0x57,0x0d,0xc1,0x95};
    static std::uint32_t divisor13     = 4075703878;
    static std::uint8_t  quotient13[32]    = {0x00,0x00,0x00,0x00,0x90,0xc3,0xca,0x7c,0x78,0x5b,0x18,0x70,0x52,0xd8,0xa6,0xd5,0xee,0x1e,0xcb,0x37,0xba,0x3f,0x50,0x29,0x95,0x39,0x69,0xf2,0x0b,0x67,0x9b,0x8f};
    static std::uint32_t remainder13      = 3663832699;
    uint256_from_bytes(dividend, dividend13);
    remainder = uint256_div_uint32(quotient, dividend, divisor13);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient13, quotient_data, 32) != 0 || remainder13 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend14[32] = {0x60,0x50,0x91,0x4a,0x9d,0x33,0xa0,0x1c,0x35,0x3c,0x63,0x1c,0xdf,0xd4,0x3f,0x37,0x12,0x00,0x33,0x9d,0x06,0x87,0x39,0xfa,0x9d,0x1d,0xe2,0xa0,0x5d,0x15,0x8a,0x2f};
    static std::uint32_t divisor14     = 2724768392;
    static std::uint8_t  quotient14[32]    = {0x00,0x00,0x00,0x00,0x97,0xd1,0x60,0x8d,0xbe,0x0e,0x37,0x08,0x9a,0x4d,0x0a,0xb6,0x58,0x09,0x03,0x82,0xfc,0x50,0x5b,0x62,0xc2,0x6b,0xa2,0x42,0x44,0x5e,0xa9,0xf9};
    static std::uint32_t remainder14      = 2395202535;
    uint256_from_bytes(dividend, dividend14);
    remainder = uint256_div_uint32(quotient, dividend, divisor14);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient14, quotient_data, 32) != 0 || remainder14 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend15[32] = {0x15,0xfc,0x89,0x9e,0x4f,0xd5,0x8d,0xbe,0x7b,0xdc,0x96,0x8b,0x7a,0xfb,0x2c,0x68,0x77,0x4b,0x15,0xd7,0xfa,0x52,0x9b,0xa3,0xfe,0x3b,0xfa,0xda,0x7c,0xf2,0x07,0x24};
    static std::uint32_t divisor15     = 438892468;
    static std::uint8_t  quotient15[32]    = {0x00,0x00,0x00,0x00,0xd7,0x28,0x6d,0x75,0x5d,0x25,0x67,0x73,0x90,0xa4,0xe2,0x21,0x10,0xc1,0x87,0x6a,0x58,0x18,0x9f,0xbe,0x32,0xd6,0xf8,0xc4,0x8d,0x48,0x58,0xf0};
    static std::uint32_t remainder15      = 314830436;
    uint256_from_bytes(dividend, dividend15);
    remainder = uint256_div_uint32(quotient, dividend, divisor15);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient15, quotient_data, 32) != 0 || remainder15 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend16[32] = {0xdd,0x02,0xde,0x92,0xa4,0x96,0x36,0xa2,0xfa,0x7f,0x0e,0xab,0x4c,0x4f,0x9b,0x06,0x87,0x32,0x2e,0x25,0xc2,0x15,0xa8,0x2a,0x06,0xec,0x41,0xad,0xea,0x05,0x75,0x43};
    static std::uint32_t divisor16     = 2990142408;
    static std::uint8_t  quotient16[32]    = {0x00,0x00,0x00,0x01,0x3d,0x74,0x80,0x79,0x71,0x03,0x75,0x86,0x17,0x8f,0x68,0x6f,0x7a,0xb5,0x08,0xd7,0x84,0xdd,0xa5,0xd4,0x56,0xa1,0x73,0x31,0x8a,0xaa,0x3a,0x2c};
    static std::uint32_t remainder16      = 1946435299;
    uint256_from_bytes(dividend, dividend16);
    remainder = uint256_div_uint32(quotient, dividend, divisor16);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient16, quotient_data, 32) != 0 || remainder16 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend17[32] = {0xc5,0x9d,0xb9,0x16,0x5b,0x0e,0xe7,0x6f,0x2a,0xc3,0x44,0x46,0xe8,0x83,0xa1,0xd4,0x5d,0xe0,0x09,0x97,0x84,0xb5,0xa8,0x18,0x42,0xd8,0x72,0x08,0xd8,0x6f,0x40,0xf6};
    static std::uint32_t divisor17     = 2287466917;
    static std::uint8_t  quotient17[32]    = {0x00,0x00,0x00,0x01,0x73,0x0b,0xb1,0x77,0x91,0x74,0x4f,0xbe,0x77,0x89,0x62,0xee,0x54,0x39,0x49,0x17,0x92,0x89,0xc9,0x7d,0x51,0x91,0x46,0xcd,0xc8,0x4c,0x64,0xed};
    static std::uint32_t remainder17      = 1014804277;
    uint256_from_bytes(dividend, dividend17);
    remainder = uint256_div_uint32(quotient, dividend, divisor17);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient17, quotient_data, 32) != 0 || remainder17 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend18[32] = {0x56,0x75,0xf6,0xad,0x32,0x5b,0x55,0xdd,0x78,0x57,0x29,0x76,0x3a,0x12,0x91,0x7c,0x1a,0x26,0xf8,0x89,0x38,0x70,0x38,0x00,0x14,0x9e,0x25,0x9b,0x5d,0x58,0xc7,0x05};
    static std::uint32_t divisor18     = 2072980150;
    static std::uint8_t  quotient18[32]    = {0x00,0x00,0x00,0x00,0xb3,0x22,0xed,0xd8,0xfa,0x61,0x5d,0xf3,0x88,0xac,0xe3,0x8a,0x98,0xc9,0x4b,0xd8,0xa3,0x8f,0xe7,0xa6,0x5b,0xfd,0x9c,0x0a,0x38,0x36,0x65,0x6d};
    static std::uint32_t remainder18      = 1931856263;
    uint256_from_bytes(dividend, dividend18);
    remainder = uint256_div_uint32(quotient, dividend, divisor18);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient18, quotient_data, 32) != 0 || remainder18 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend19[32] = {0xe8,0xe7,0x27,0x89,0x1e,0xb2,0x01,0x09,0xa9,0x1c,0x24,0x39,0xd5,0xab,0x8b,0x4d,0x15,0xb4,0x0a,0xeb,0xa4,0xa4,0x5e,0xff,0xcc,0xb5,0x73,0xd9,0x58,0x10,0xd6,0x0e};
    static std::uint32_t divisor19     = 3359965297;
    static std::uint8_t  quotient19[32]    = {0x00,0x00,0x00,0x01,0x29,0xb6,0xec,0x70,0x9c,0xed,0x3c,0xa7,0xbc,0x64,0x98,0x69,0xb9,0x4e,0x7e,0x0d,0x33,0xd6,0x4f,0xc8,0x02,0xbb,0x6a,0x7e,0x94,0x4e,0xaf,0x10};
    static std::uint32_t remainder19      = 839225342;
    uint256_from_bytes(dividend, dividend19);
    remainder = uint256_div_uint32(quotient, dividend, divisor19);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient19, quotient_data, 32) != 0 || remainder19 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend20[32] = {0x76,0x91,0xb0,0x6f,0x65,0x55,0xab,0xfe,0xb8,0xc9,0x81,0x7a,0xf8,0xbe,0x88,0x31,0xf2,0x37,0xe4,0x5a,0xcd,0x02,0xc5,0xe1,0x16,0x35,0x3d,0x03,0x55,0x1f,0xd8,0xf9};
    static std::uint32_t divisor20     = 3192675559;
    static std::uint8_t  quotient20[32]    = {0x00,0x00,0x00,0x00,0x9f,0x81,0x7e,0xcb,0xd6,0xc6,0x63,0xad,0xda,0xba,0x22,0xae,0x5f,0x10,0xa4,0x0a,0x15,0xe7,0x67,0x52,0x76,0x05,0x36,0x94,0xe7,0x51,0xec,0x0e};
    static std::uint32_t remainder20      = 2973159511;
    uint256_from_bytes(dividend, dividend20);
    remainder = uint256_div_uint32(quotient, dividend, divisor20);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient20, quotient_data, 32) != 0 || remainder20 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend21[32] = {0x07,0x0d,0x71,0x09,0x20,0x85,0x96,0x34,0xfe,0x3c,0x9c,0x8f,0x2b,0x85,0x5c,0x1f,0x28,0xaa,0xca,0x51,0xb9,0x8c,0x67,0xc2,0x15,0xbd,0x44,0x8f,0xf2,0x61,0x49,0xed};
    static std::uint32_t divisor21     = 2537519495;
    static std::uint8_t  quotient21[32]    = {0x00,0x00,0x00,0x00,0x0b,0xef,0xdc,0xf9,0x5a,0x3b,0x53,0xdb,0xf1,0x0f,0x71,0x4f,0x73,0xbd,0x26,0xf0,0xf9,0x93,0x64,0x09,0xe1,0xaa,0x4a,0x8e,0xd3,0x27,0xce,0x3b};
    static std::uint32_t remainder21      = 979674576;
    uint256_from_bytes(dividend, dividend21);
    remainder = uint256_div_uint32(quotient, dividend, divisor21);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient21, quotient_data, 32) != 0 || remainder21 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend22[32] = {0x21,0x88,0x28,0x7e,0x8c,0x5c,0x71,0x5f,0x8c,0x74,0xfc,0x1e,0x27,0xe9,0xe0,0x6f,0x59,0xb4,0x4e,0x92,0xef,0xfd,0xde,0xea,0xa8,0x42,0xbc,0x19,0x79,0x6f,0x74,0xad};
    static std::uint32_t divisor22     = 61172930;
    static std::uint8_t  quotient22[32]    = {0x00,0x00,0x00,0x09,0x32,0x47,0xf9,0x6f,0xd5,0xcf,0x46,0x89,0xa3,0x1c,0x89,0x54,0xe1,0x8a,0xd3,0xc9,0x70,0x73,0x5f,0x7f,0xa9,0xbe,0xd9,0xb9,0xb2,0x75,0x75,0xe5};
    static std::uint32_t remainder22      = 51806499;
    uint256_from_bytes(dividend, dividend22);
    remainder = uint256_div_uint32(quotient, dividend, divisor22);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient22, quotient_data, 32) != 0 || remainder22 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend23[32] = {0xef,0x02,0x09,0x0b,0xbf,0xde,0xfc,0x15,0x86,0xce,0x03,0xf9,0x1a,0x4f,0x44,0xf9,0xa6,0x51,0x14,0x45,0xb9,0xf3,0x63,0x5c,0xf8,0x8c,0x42,0x2b,0xcc,0xa2,0xa9,0x2b};
    static std::uint32_t divisor23     = 1863197322;
    static std::uint8_t  quotient23[32]    = {0x00,0x00,0x00,0x02,0x26,0xf3,0x94,0x81,0xcc,0xab,0xd0,0xcd,0x2a,0x0d,0xa1,0x8c,0x32,0x5e,0x1f,0x48,0x28,0x4f,0x67,0x0b,0x1b,0x57,0x57,0x90,0xef,0xa5,0x5c,0xa5};
    static std::uint32_t remainder23      = 187354681;
    uint256_from_bytes(dividend, dividend23);
    remainder = uint256_div_uint32(quotient, dividend, divisor23);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient23, quotient_data, 32) != 0 || remainder23 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend24[32] = {0x40,0x78,0x3f,0x0a,0x07,0x2a,0x98,0xd2,0x36,0x06,0xde,0xfc,0xdf,0xb8,0x5c,0x0d,0xd3,0x7e,0xe9,0x15,0x31,0xde,0xc4,0xf4,0xdf,0x2a,0x8b,0x79,0xfc,0x8e,0x80,0xb3};
    static std::uint32_t divisor24     = 1258282194;
    static std::uint8_t  quotient24[32]    = {0x00,0x00,0x00,0x00,0xdc,0x0e,0xe5,0xa5,0xe8,0xed,0x61,0x34,0xf9,0x13,0x0c,0x26,0x58,0x13,0xbf,0x19,0x18,0x79,0xc9,0x2d,0x34,0x14,0xd0,0xe4,0xf3,0xf0,0x3d,0x54};
    static std::uint32_t remainder24      = 236716491;
    uint256_from_bytes(dividend, dividend24);
    remainder = uint256_div_uint32(quotient, dividend, divisor24);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient24, quotient_data, 32) != 0 || remainder24 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend25[32] = {0x80,0x6c,0x10,0xb5,0xe0,0xcf,0xab,0x4c,0xea,0xef,0xc4,0xd2,0xd3,0xbf,0x6d,0x01,0x6b,0xae,0x4b,0x5b,0x84,0x4a,0x70,0x34,0xe7,0x7f,0xfe,0x48,0xd0,0xa6,0xec,0x17};
    static std::uint32_t divisor25     = 2284170839;
    static std::uint8_t  quotient25[32]    = {0x00,0x00,0x00,0x00,0xf1,0x79,0x74,0x28,0x6c,0xb0,0xf4,0xe9,0xfd,0x34,0x84,0xeb,0x0c,0x65,0x16,0xc2,0x47,0x1c,0xac,0xe7,0x48,0xa7,0x7c,0x44,0x8b,0xb0,0xe8,0x6c};
    static std::uint32_t remainder25      = 569542499;
    uint256_from_bytes(dividend, dividend25);
    remainder = uint256_div_uint32(quotient, dividend, divisor25);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient25, quotient_data, 32) != 0 || remainder25 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend26[32] = {0x8e,0x31,0x70,0x41,0x87,0xdd,0xae,0xb7,0x84,0xb2,0x80,0x54,0xae,0xad,0x44,0xb0,0x53,0x73,0x90,0xe5,0x0f,0xcf,0x31,0xca,0x8e,0x75,0x2f,0xdf,0x1e,0xce,0x61,0x5d};
    static std::uint32_t divisor26     = 3368424627;
    static std::uint8_t  quotient26[32]    = {0x00,0x00,0x00,0x00,0xb5,0x4e,0x46,0x78,0x7f,0x45,0xd5,0x21,0x92,0x3e,0x64,0x10,0xd7,0x4e,0xaa,0x8e,0xff,0x63,0x57,0x32,0x49,0xc7,0xf9,0xd9,0xba,0x82,0xd8,0x24};
    static std::uint32_t remainder26      = 815165489;
    uint256_from_bytes(dividend, dividend26);
    remainder = uint256_div_uint32(quotient, dividend, divisor26);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient26, quotient_data, 32) != 0 || remainder26 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend27[32] = {0x46,0xe4,0x09,0x90,0x30,0xf9,0x70,0x58,0x3f,0x9d,0x52,0xf9,0x0e,0x8b,0xec,0x94,0x8f,0x6f,0x91,0x5f,0xe2,0x1b,0x37,0xca,0x1b,0x29,0xfc,0x99,0xc6,0xc8,0x0e,0x2b};
    static std::uint32_t divisor27     = 3316836187;
    static std::uint8_t  quotient27[32]    = {0x00,0x00,0x00,0x00,0x5b,0xcb,0xdf,0x50,0xfc,0xfd,0x7e,0x12,0x17,0x9b,0xa3,0xc3,0x63,0x88,0xb3,0xab,0x67,0x5c,0x7b,0x4a,0x07,0x29,0x15,0x5f,0xad,0xcd,0x96,0x7f};
    static std::uint32_t remainder27      = 479786502;
    uint256_from_bytes(dividend, dividend27);
    remainder = uint256_div_uint32(quotient, dividend, divisor27);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient27, quotient_data, 32) != 0 || remainder27 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend28[32] = {0xe9,0x98,0xd0,0xee,0xe4,0xdd,0xf9,0xb9,0xc2,0x8e,0xe9,0x07,0x07,0x22,0x35,0xc2,0x8f,0xcd,0x7f,0x40,0x73,0xc1,0xcd,0x2c,0x81,0xf9,0x8b,0x52,0x19,0x05,0xd5,0x91};
    static std::uint32_t divisor28     = 1903737355;
    static std::uint8_t  quotient28[32]    = {0x00,0x00,0x00,0x02,0x0f,0x02,0xe8,0x61,0xe2,0x97,0x02,0x7f,0x2c,0x80,0x19,0x56,0x77,0x5d,0xaa,0xd7,0xe3,0x92,0x68,0x37,0x63,0x30,0xe6,0xa2,0x39,0x3a,0xc5,0x98};
    static std::uint32_t remainder28      = 950986761;
    uint256_from_bytes(dividend, dividend28);
    remainder = uint256_div_uint32(quotient, dividend, divisor28);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient28, quotient_data, 32) != 0 || remainder28 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend29[32] = {0xb1,0x56,0xd1,0xad,0x33,0x0c,0x16,0xa3,0x83,0x1d,0x03,0xbf,0x9b,0x2b,0xd6,0xc0,0x81,0x6b,0xee,0x06,0xf9,0x2e,0x23,0x39,0x9c,0xce,0xa0,0x98,0x53,0x5b,0x6a,0x43};
    static std::uint32_t divisor29     = 1942810372;
    static std::uint8_t  quotient29[32]    = {0x00,0x00,0x00,0x01,0x88,0x0b,0x15,0xd6,0x6c,0x3a,0x96,0x64,0xcb,0x9e,0xba,0x13,0xf0,0x98,0xb0,0x30,0x85,0x4d,0x24,0x63,0xe3,0xf4,0x1d,0xa5,0xe3,0x54,0xe5,0x8b};
    static std::uint32_t remainder29      = 670502679;
    uint256_from_bytes(dividend, dividend29);
    remainder = uint256_div_uint32(quotient, dividend, divisor29);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient29, quotient_data, 32) != 0 || remainder29 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend30[32] = {0x71,0x2e,0xa6,0xb3,0x64,0x71,0xfd,0xe4,0x1f,0x22,0x9d,0xd0,0x6a,0xa8,0xb9,0xe0,0x23,0x1b,0x3e,0x14,0x72,0x91,0x35,0xbd,0xd7,0x0a,0x39,0xd1,0x33,0xdc,0xd7,0x7f};
    static std::uint32_t divisor30     = 311583110;
    static std::uint8_t  quotient30[32]    = {0x00,0x00,0x00,0x06,0x18,0x24,0x6b,0xf7,0x31,0xb1,0x6a,0x82,0x0a,0xa3,0xe6,0xf2,0x3b,0xe2,0x30,0x40,0xf7,0x22,0x7c,0xa9,0x96,0x39,0x3e,0xa7,0x98,0xed,0xa5,0x29};
    static std::uint32_t remainder30      = 142727945;
    uint256_from_bytes(dividend, dividend30);
    remainder = uint256_div_uint32(quotient, dividend, divisor30);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient30, quotient_data, 32) != 0 || remainder30 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend31[32] = {0xc8,0xb0,0x07,0xee,0x4d,0x82,0xfe,0xac,0xab,0x62,0x86,0xcd,0x36,0x72,0xd6,0xae,0x12,0xb8,0x0a,0xed,0x6d,0xa7,0x9a,0x87,0x3d,0x9a,0x80,0x79,0xab,0xd0,0xd7,0xfb};
    static std::uint32_t divisor31     = 3852699199;
    static std::uint8_t  quotient31[32]    = {0x00,0x00,0x00,0x00,0xdf,0xb9,0xb5,0x82,0x33,0x4f,0xef,0x18,0x8d,0xe4,0x99,0x14,0x4f,0x84,0xec,0x59,0xeb,0xeb,0x6c,0xe4,0xf3,0xa3,0x07,0xa8,0xe1,0xc0,0xcf,0xe8};
    static std::uint32_t remainder31      = 1204960739;
    uint256_from_bytes(dividend, dividend31);
    remainder = uint256_div_uint32(quotient, dividend, divisor31);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient31, quotient_data, 32) != 0 || remainder31 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend32[32] = {0x24,0x9a,0x45,0x84,0x5d,0xbe,0x30,0x23,0xa9,0x06,0x92,0x2f,0xa4,0xb9,0xa9,0xc4,0xb7,0x53,0xa1,0xee,0xf0,0x83,0x60,0x85,0x27,0x89,0xd0,0x59,0xc6,0xe5,0x0d,0xf2};
    static std::uint32_t divisor32     = 3791738147;
    static std::uint8_t  quotient32[32]    = {0x00,0x00,0x00,0x00,0x29,0x75,0xde,0x52,0x57,0xc6,0x5a,0x93,0xc3,0x1e,0xfe,0xf4,0x4f,0x28,0x13,0x2c,0xc2,0x0b,0xc5,0x7b,0x29,0xbe,0xa9,0xff,0x68,0x3e,0xb5,0xe3};
    static std::uint32_t remainder32      = 2550845673;
    uint256_from_bytes(dividend, dividend32);
    remainder = uint256_div_uint32(quotient, dividend, divisor32);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient32, quotient_data, 32) != 0 || remainder32 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend33[32] = {0xb4,0xd1,0x9e,0xc1,0x29,0x55,0xd6,0xf0,0x39,0x45,0x33,0x6b,0xd5,0x1b,0x18,0x15,0xaa,0xf7,0x19,0xf3,0xfd,0x68,0x37,0x3b,0x29,0xac,0xf1,0xa5,0x7c,0xbd,0x1f,0x5a};
    static std::uint32_t divisor33     = 4269509349;
    static std::uint8_t  quotient33[32]    = {0x00,0x00,0x00,0x00,0xb5,0xe5,0xa1,0xff,0xd3,0x54,0x24,0x07,0x93,0x17,0x65,0xe8,0x7e,0x85,0xdc,0x50,0x1a,0x2d,0x9f,0x83,0x5d,0x38,0x5d,0x1d,0xe2,0x78,0xab,0x30};
    static std::uint32_t remainder33      = 4201913706;
    uint256_from_bytes(dividend, dividend33);
    remainder = uint256_div_uint32(quotient, dividend, divisor33);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient33, quotient_data, 32) != 0 || remainder33 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend34[32] = {0x04,0xa1,0x05,0x47,0xb4,0x01,0xba,0x85,0x70,0xc1,0xdc,0xa1,0x75,0x6b,0x72,0x89,0x8d,0xd6,0x3c,0xb9,0x56,0x85,0xd6,0x24,0x04,0xfc,0xd5,0x55,0x5d,0xaf,0x10,0x6d};
    static std::uint32_t divisor34     = 1423772582;
    static std::uint8_t  quotient34[32]    = {0x00,0x00,0x00,0x00,0x0d,0xf6,0xbe,0xe2,0x50,0x8e,0x47,0x90,0x30,0x99,0x51,0x55,0xc4,0x78,0x1d,0xd3,0x0a,0x9a,0x71,0x0c,0xe5,0xbe,0xe7,0xec,0x92,0x4c,0x24,0x4e};
    static std::uint32_t remainder34      = 1265249241;
    uint256_from_bytes(dividend, dividend34);
    remainder = uint256_div_uint32(quotient, dividend, divisor34);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient34, quotient_data, 32) != 0 || remainder34 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend35[32] = {0x45,0x9c,0x94,0x5c,0x43,0xfc,0x05,0x27,0x15,0x85,0x0a,0x03,0x1a,0xd2,0xd5,0xf1,0xe0,0x5b,0x3e,0x13,0xf8,0xc1,0x10,0xfb,0x3a,0x82,0x81,0x59,0xc9,0xd2,0x29,0x50};
    static std::uint32_t divisor35     = 3890805239;
    static std::uint8_t  quotient35[32]    = {0x00,0x00,0x00,0x00,0x4c,0xd7,0xb6,0xad,0xb8,0xc7,0xd9,0xfb,0x6b,0x4d,0x80,0x5c,0xf0,0x72,0xe6,0xcf,0x2e,0xce,0xce,0x63,0x51,0x6a,0xfe,0xe3,0xdc,0x60,0xab,0x44};
    static std::uint32_t remainder35      = 2421671604;
    uint256_from_bytes(dividend, dividend35);
    remainder = uint256_div_uint32(quotient, dividend, divisor35);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient35, quotient_data, 32) != 0 || remainder35 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend36[32] = {0xa2,0x6a,0xa0,0xae,0x04,0x4f,0x15,0x74,0xf0,0x37,0xaf,0xc6,0x44,0xd8,0x2a,0x53,0x12,0x89,0xba,0xfa,0xe5,0x31,0x69,0x60,0x6c,0xe1,0x93,0xc2,0x2e,0xef,0xa2,0x79};
    static std::uint32_t divisor36     = 3442968591;
    static std::uint8_t  quotient36[32]    = {0x00,0x00,0x00,0x00,0xca,0x9b,0xb2,0x02,0xbb,0x5b,0x19,0x37,0x21,0x44,0x66,0x9e,0x83,0x73,0xc3,0x39,0x5a,0xcf,0xaf,0xc5,0xe7,0x2e,0x97,0x0c,0x15,0x9e,0x2c,0x6f};
    static std::uint32_t remainder36      = 1949765624;
    uint256_from_bytes(dividend, dividend36);
    remainder = uint256_div_uint32(quotient, dividend, divisor36);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient36, quotient_data, 32) != 0 || remainder36 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend37[32] = {0xdc,0xde,0xd2,0x04,0x43,0xb3,0x0f,0x66,0x11,0x0e,0x2c,0xb6,0x38,0xef,0xba,0xeb,0xdb,0x31,0xcc,0xd2,0x9b,0xb1,0x83,0xe1,0x15,0x70,0x26,0x6b,0x42,0xb3,0x87,0x55};
    static std::uint32_t divisor37     = 1948942436;
    static std::uint8_t  quotient37[32]    = {0x00,0x00,0x00,0x01,0xe6,0xbd,0xd1,0x20,0xe9,0x05,0xec,0x45,0x1d,0x47,0xc5,0x12,0xe8,0x4d,0xa4,0xbc,0x2b,0x50,0x05,0x97,0xbf,0x6e,0x74,0x72,0xb3,0x4f,0x37,0x17};
    static std::uint32_t remainder37      = 644907609;
    uint256_from_bytes(dividend, dividend37);
    remainder = uint256_div_uint32(quotient, dividend, divisor37);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient37, quotient_data, 32) != 0 || remainder37 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend38[32] = {0xf8,0x1e,0x54,0xdd,0x1c,0x05,0x02,0xc6,0xf0,0x29,0x05,0x31,0x3d,0x0a,0x27,0x0b,0xb5,0xa4,0x32,0xcf,0x86,0xe3,0xe7,0x26,0x0b,0x0f,0x87,0x3b,0x21,0x14,0xe0,0x68};
    static std::uint32_t divisor38     = 1124831726;
    static std::uint8_t  quotient38[32]    = {0x00,0x00,0x00,0x03,0xb3,0x65,0x4e,0x2c,0x47,0x49,0x54,0x61,0x72,0xa6,0x05,0xd3,0x8a,0xb3,0x6b,0x65,0x56,0x8e,0x46,0x87,0x6a,0x6b,0x36,0xe9,0x27,0x38,0x4b,0xcc};
    static std::uint32_t remainder38      = 571202752;
    uint256_from_bytes(dividend, dividend38);
    remainder = uint256_div_uint32(quotient, dividend, divisor38);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient38, quotient_data, 32) != 0 || remainder38 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend39[32] = {0xe3,0x83,0x8b,0x9e,0xd5,0xa9,0x42,0x2a,0x8b,0xc0,0x83,0x11,0x7e,0xb8,0x6c,0x57,0xa8,0x11,0x00,0xa1,0x6e,0xa3,0x30,0xa1,0xa6,0x6d,0x58,0xb5,0xd1,0xa4,0xc0,0x1e};
    static std::uint32_t divisor39     = 4167460015;
    static std::uint8_t  quotient39[32]    = {0x00,0x00,0x00,0x00,0xea,0x79,0x8f,0x73,0x84,0xa5,0x63,0x99,0x5f,0xaa,0xbb,0xb1,0x28,0x5d,0xc3,0x36,0x5a,0xe6,0x4d,0xa1,0x72,0x1e,0x8a,0xdc,0x43,0xa8,0xb2,0x0f};
    static std::uint32_t remainder39      = 835398621;
    uint256_from_bytes(dividend, dividend39);
    remainder = uint256_div_uint32(quotient, dividend, divisor39);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient39, quotient_data, 32) != 0 || remainder39 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend40[32] = {0xe1,0x3e,0x21,0x3e,0xbd,0xaa,0xea,0x00,0xa0,0x1d,0x61,0x6f,0x12,0x1a,0xe3,0xe6,0x03,0xa6,0x39,0x66,0x21,0x3b,0xca,0x7f,0xd6,0x44,0xde,0x2f,0x0d,0xec,0x68,0x23};
    static std::uint32_t divisor40     = 1850017270;
    static std::uint8_t  quotient40[32]    = {0x00,0x00,0x00,0x02,0x0a,0xeb,0x60,0xe0,0xac,0x4c,0xc8,0x40,0x31,0x26,0x49,0x3d,0x54,0x9a,0xc9,0x85,0x86,0xf1,0x18,0x5d,0x84,0x5c,0xcc,0xe3,0x29,0x93,0x69,0x8b};
    static std::uint32_t remainder40      = 213796241;
    uint256_from_bytes(dividend, dividend40);
    remainder = uint256_div_uint32(quotient, dividend, divisor40);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient40, quotient_data, 32) != 0 || remainder40 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend41[32] = {0x75,0x9e,0xb5,0x59,0x0b,0x94,0xaf,0x3a,0x4b,0x05,0xe1,0xae,0xb1,0x53,0xd6,0x9c,0x3e,0x01,0xaa,0xa6,0x99,0x49,0x8a,0xc4,0x48,0x2c,0xc7,0x8e,0xf8,0x8e,0xde,0x10};
    static std::uint32_t divisor41     = 676598821;
    static std::uint8_t  quotient41[32]    = {0x00,0x00,0x00,0x02,0xea,0xa3,0x20,0x71,0x8e,0x23,0x1a,0xd4,0x80,0xcd,0xaf,0x75,0xfa,0xbf,0xe6,0x68,0xfe,0xd6,0xad,0x99,0xce,0x44,0xd2,0x2d,0x9e,0xf7,0x88,0x78};
    static std::uint32_t remainder41      = 549373112;
    uint256_from_bytes(dividend, dividend41);
    remainder = uint256_div_uint32(quotient, dividend, divisor41);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient41, quotient_data, 32) != 0 || remainder41 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend42[32] = {0x37,0xc6,0x0e,0x98,0x4f,0x3e,0x88,0x5e,0xe1,0xe4,0x37,0xb7,0xf7,0x35,0xef,0xe6,0x08,0xd1,0x80,0x11,0x3e,0x94,0x0b,0xb4,0x52,0xd3,0x1e,0x1b,0x8c,0x0d,0x00,0x33};
    static std::uint32_t divisor42     = 785798162;
    static std::uint8_t  quotient42[32]    = {0x00,0x00,0x00,0x01,0x30,0xd8,0x20,0x5e,0x0f,0x92,0xc8,0x0d,0x52,0x53,0x43,0xb3,0x8b,0x6d,0xb1,0x22,0x4f,0x97,0xab,0x25,0xea,0x15,0xa7,0xaa,0x4d,0x7e,0x28,0x53};
    static std::uint32_t remainder42      = 345042525;
    uint256_from_bytes(dividend, dividend42);
    remainder = uint256_div_uint32(quotient, dividend, divisor42);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient42, quotient_data, 32) != 0 || remainder42 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend43[32] = {0xa7,0xf0,0xc9,0x9e,0x80,0xb5,0x24,0x4a,0x47,0x67,0xe1,0xfa,0x79,0x82,0x3e,0xb2,0x15,0x79,0xda,0x0a,0x61,0xb2,0x48,0x0c,0x55,0xd8,0x5e,0x8d,0x00,0x46,0x0d,0x69};
    static std::uint32_t divisor43     = 1065922394;
    static std::uint8_t  quotient43[32]    = {0x00,0x00,0x00,0x02,0xa4,0xb0,0xb3,0xc0,0x47,0x5b,0xd3,0xd2,0xd8,0x9f,0x49,0xc0,0x00,0x60,0xf9,0x92,0x95,0xf4,0xca,0xf9,0xe0,0x0c,0x87,0xaa,0x62,0x45,0x0f,0x61};
    static std::uint32_t remainder43      = 871585359;
    uint256_from_bytes(dividend, dividend43);
    remainder = uint256_div_uint32(quotient, dividend, divisor43);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient43, quotient_data, 32) != 0 || remainder43 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend44[32] = {0x24,0xd4,0x58,0x9c,0x16,0xfa,0x14,0x21,0xd1,0x29,0xd0,0x67,0x43,0xa0,0x8f,0x06,0x17,0x42,0x0e,0x94,0x01,0x44,0x70,0x2b,0xc6,0xb7,0x89,0xef,0x81,0x36,0x5a,0xcc};
    static std::uint32_t divisor44     = 2520289960;
    static std::uint8_t  quotient44[32]    = {0x00,0x00,0x00,0x00,0x3e,0xc3,0x5f,0x6e,0x41,0x3a,0x8b,0x8d,0xd0,0x70,0x39,0xe0,0xf5,0x59,0xc9,0x17,0xb2,0x4a,0x5e,0x00,0x0b,0xae,0x5e,0x70,0xa6,0xe2,0xa9,0x62};
    static std::uint32_t remainder44      = 1047350908;
    uint256_from_bytes(dividend, dividend44);
    remainder = uint256_div_uint32(quotient, dividend, divisor44);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient44, quotient_data, 32) != 0 || remainder44 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend45[32] = {0x7e,0x83,0x49,0x04,0xfc,0x17,0x34,0x98,0xb8,0x7e,0x4e,0x2b,0x53,0x7d,0x91,0x28,0xc3,0xa9,0xe8,0x89,0x63,0xb7,0x59,0xf5,0x98,0xb8,0x1c,0x66,0xe1,0x0c,0x16,0x7d};
    static std::uint32_t divisor45     = 1220529104;
    static std::uint8_t  quotient45[32]    = {0x00,0x00,0x00,0x01,0xbd,0x30,0xe0,0x6a,0xec,0xf6,0x55,0x6e,0xa0,0x3b,0x19,0x5d,0xaf,0xda,0x89,0x0b,0xe2,0x01,0xd2,0xdc,0x69,0x2d,0x6c,0xbc,0x6a,0xb4,0x6a,0xfd};
    static std::uint32_t remainder45      = 584813037;
    uint256_from_bytes(dividend, dividend45);
    remainder = uint256_div_uint32(quotient, dividend, divisor45);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient45, quotient_data, 32) != 0 || remainder45 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend46[32] = {0xf5,0xa2,0xd8,0x79,0x5c,0x57,0x53,0x2b,0xa3,0x1a,0x49,0xdd,0x22,0x12,0x65,0x40,0x0a,0xb7,0x79,0x88,0x07,0xfa,0x22,0xf7,0x15,0xc8,0x91,0xff,0x3a,0xdd,0x65,0x27};
    static std::uint32_t divisor46     = 1617563116;
    static std::uint8_t  quotient46[32]    = {0x00,0x00,0x00,0x02,0x8c,0x37,0x10,0x8b,0xdf,0x86,0x70,0x8d,0xb7,0x63,0xb9,0xa3,0x0b,0x33,0x95,0x60,0xa6,0xd2,0x17,0xe9,0xcb,0x67,0xfd,0x76,0x3d,0x91,0x1a,0x18};
    static std::uint32_t remainder46      = 1289101063;
    uint256_from_bytes(dividend, dividend46);
    remainder = uint256_div_uint32(quotient, dividend, divisor46);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient46, quotient_data, 32) != 0 || remainder46 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend47[32] = {0xd8,0x74,0xbc,0x79,0x7e,0x73,0x6d,0x5f,0x75,0xd8,0xd8,0xa4,0xf9,0xc9,0xc6,0x79,0xa6,0x61,0xf6,0x2c,0xbd,0x65,0x68,0x0c,0x3b,0x11,0x85,0xd9,0x34,0x89,0x22,0xd7};
    static std::uint32_t divisor47     = 329595264;
    static std::uint8_t  quotient47[32]    = {0x00,0x00,0x00,0x0b,0x04,0xa5,0x48,0xc2,0xff,0x03,0x91,0x71,0x66,0x42,0xe5,0xd5,0x18,0x81,0x93,0x99,0xc4,0xff,0x5c,0x28,0x39,0x8a,0x91,0xab,0x5c,0xfa,0xad,0xbb};
    static std::uint32_t remainder47      = 201106007;
    uint256_from_bytes(dividend, dividend47);
    remainder = uint256_div_uint32(quotient, dividend, divisor47);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient47, quotient_data, 32) != 0 || remainder47 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend48[32] = {0x7c,0x5d,0x42,0xdc,0x0f,0x87,0x7a,0xe3,0x7b,0x7f,0xec,0x4b,0x03,0x31,0x2e,0xad,0x22,0x29,0x30,0xae,0x91,0x58,0xd4,0xa8,0x9f,0x03,0xbc,0x5a,0x4d,0xee,0x48,0x12};
    static std::uint32_t divisor48     = 4176894381;
    static std::uint8_t  quotient48[32]    = {0x00,0x00,0x00,0x00,0x7f,0xe1,0x3d,0x8b,0x8e,0x42,0xc1,0x01,0xb9,0x6d,0x1e,0xc4,0x56,0xcc,0x1a,0x84,0x2b,0x5c,0x8b,0xb9,0x9f,0xda,0x14,0xba,0xb1,0x94,0xd4,0x10};
    static std::uint32_t remainder48      = 1195469122;
    uint256_from_bytes(dividend, dividend48);
    remainder = uint256_div_uint32(quotient, dividend, divisor48);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient48, quotient_data, 32) != 0 || remainder48 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend49[32] = {0x4a,0x22,0x7f,0x39,0x04,0x7b,0x2c,0x10,0x79,0x12,0xef,0x4a,0xef,0xae,0x5d,0x4e,0x15,0xfa,0x8b,0x65,0xfa,0x66,0x72,0xcd,0x4f,0xc9,0xe9,0x18,0x33,0x02,0x0c,0xcd};
    static std::uint32_t divisor49     = 328411397;
    static std::uint8_t  quotient49[32]    = {0x00,0x00,0x00,0x03,0xc9,0x88,0xf5,0x95,0xea,0x4e,0x73,0x5f,0x6f,0x57,0x15,0x72,0x83,0xe3,0x56,0x4a,0xc7,0x22,0x2e,0x0f,0xb3,0xba,0x5a,0x52,0x14,0xe5,0x15,0x90};
    static std::uint32_t remainder49      = 140808445;
    uint256_from_bytes(dividend, dividend49);
    remainder = uint256_div_uint32(quotient, dividend, divisor49);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient49, quotient_data, 32) != 0 || remainder49 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend50[32] = {0x63,0x08,0x7e,0x52,0x44,0xc6,0xb8,0x95,0xfe,0x74,0x9e,0x67,0x73,0x0f,0x37,0xf1,0xfe,0x9e,0xb4,0xad,0xf7,0xd5,0xf1,0x24,0x81,0xb1,0xc0,0x25,0xd1,0xe4,0xd0,0xa3};
    static std::uint32_t divisor50     = 3936572781;
    static std::uint8_t  quotient50[32]    = {0x00,0x00,0x00,0x00,0x6c,0x0c,0xa4,0x56,0xe5,0x32,0x48,0xb8,0x3d,0xe9,0x18,0x0d,0x8b,0x29,0x6f,0x24,0x57,0x73,0x91,0x0d,0x22,0x07,0xd3,0x70,0x74,0x92,0xc6,0x22};
    static std::uint32_t remainder50      = 938945065;
    uint256_from_bytes(dividend, dividend50);
    remainder = uint256_div_uint32(quotient, dividend, divisor50);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient50, quotient_data, 32) != 0 || remainder50 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend51[32] = {0x82,0x3d,0x11,0xed,0xa1,0xb5,0x01,0xd6,0xd1,0xf9,0xbd,0xfe,0x9a,0x76,0x2d,0x54,0x21,0xf2,0x67,0xe2,0x5c,0x0b,0xb4,0x0f,0xf3,0xe6,0xca,0x73,0x43,0x05,0xe9,0x86};
    static std::uint32_t divisor51     = 3809043994;
    static std::uint8_t  quotient51[32]    = {0x00,0x00,0x00,0x00,0x92,0xda,0x6b,0xe7,0x12,0x80,0xef,0x9b,0xca,0xeb,0xec,0xdb,0x88,0xeb,0x84,0x2b,0xb0,0xdd,0x70,0xfd,0xf6,0x88,0xe0,0xae,0x36,0x88,0x0d,0xcf};
    static std::uint32_t remainder51      = 2053965952;
    uint256_from_bytes(dividend, dividend51);
    remainder = uint256_div_uint32(quotient, dividend, divisor51);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient51, quotient_data, 32) != 0 || remainder51 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend52[32] = {0x7c,0x73,0xb6,0xc9,0xe0,0x4b,0x0d,0xce,0xe5,0xd0,0x0a,0x4d,0x7f,0x75,0x95,0xb5,0x3b,0x3b,0xf4,0xbf,0x5d,0x7c,0xfe,0xd1,0xb4,0x0d,0xe5,0x6d,0x1c,0xd8,0x6f,0xc1};
    static std::uint32_t divisor52     = 106662966;
    static std::uint8_t  quotient52[32]    = {0x00,0x00,0x00,0x13,0x93,0x46,0x09,0x85,0x51,0xff,0x80,0xd8,0x6b,0xb4,0x1e,0xe2,0x09,0xab,0x77,0x04,0xdf,0xc5,0xfe,0x68,0x92,0x09,0xe5,0x7c,0x37,0xf1,0xf0,0x1b};
    static std::uint32_t remainder52      = 82314767;
    uint256_from_bytes(dividend, dividend52);
    remainder = uint256_div_uint32(quotient, dividend, divisor52);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient52, quotient_data, 32) != 0 || remainder52 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend53[32] = {0x54,0xd1,0xac,0x6b,0xd7,0x19,0x61,0x89,0x1e,0xf3,0xea,0x44,0x50,0xea,0x7d,0xa7,0x60,0x48,0x7e,0x15,0x58,0x0d,0xc5,0xab,0x6a,0x8a,0xd9,0xcb,0x24,0x05,0x63,0x60};
    static std::uint32_t divisor53     = 1393921253;
    static std::uint8_t  quotient53[32]    = {0x00,0x00,0x00,0x01,0x05,0x58,0x70,0x0d,0xe2,0xea,0x36,0xec,0x18,0xca,0x71,0xd5,0x18,0xf3,0xe8,0x7d,0x36,0x8c,0x90,0x15,0x27,0x6f,0x4a,0x2e,0xdc,0xc4,0xa3,0x80};
    static std::uint32_t remainder53      = 892674528;
    uint256_from_bytes(dividend, dividend53);
    remainder = uint256_div_uint32(quotient, dividend, divisor53);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient53, quotient_data, 32) != 0 || remainder53 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend54[32] = {0x64,0x95,0x0d,0xc2,0x10,0xa2,0x5b,0x19,0x5f,0x49,0xf0,0xfc,0x40,0xd2,0x84,0x06,0x4a,0x32,0x7e,0x2d,0xbd,0x6a,0x99,0x6d,0xe6,0xcd,0x10,0xf1,0x03,0x00,0x30,0x05};
    static std::uint32_t divisor54     = 4289781151;
    static std::uint8_t  quotient54[32]    = {0x00,0x00,0x00,0x00,0x64,0xb4,0x2e,0xe2,0x9f,0x11,0x4e,0x6f,0x25,0x90,0x03,0x87,0xb3,0xbc,0x57,0x6f,0x63,0x8c,0x22,0xd9,0xd3,0x5c,0xf5,0xb9,0x29,0xcc,0xa9,0xcf};
    static std::uint32_t remainder54      = 1861944692;
    uint256_from_bytes(dividend, dividend54);
    remainder = uint256_div_uint32(quotient, dividend, divisor54);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient54, quotient_data, 32) != 0 || remainder54 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend55[32] = {0xb8,0x35,0xe8,0xa5,0x34,0x14,0x5e,0x87,0x8c,0x9a,0x37,0x51,0x8d,0xdc,0xf8,0x3c,0xf0,0xd1,0xab,0x56,0xe0,0x2f,0x9a,0x72,0xe9,0xd6,0x25,0xc9,0x66,0x69,0x21,0x58};
    static std::uint32_t divisor55     = 212497939;
    static std::uint8_t  quotient55[32]    = {0x00,0x00,0x00,0x0e,0x8b,0x3a,0x8a,0xf7,0x86,0x8d,0x0a,0x3a,0xdc,0x69,0xc2,0x9a,0x00,0xfd,0x80,0x3d,0x07,0xd1,0xaa,0x23,0xa0,0xe4,0x7e,0x13,0xcd,0x1e,0xef,0x7d};
    static std::uint32_t remainder55      = 95927569;
    uint256_from_bytes(dividend, dividend55);
    remainder = uint256_div_uint32(quotient, dividend, divisor55);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient55, quotient_data, 32) != 0 || remainder55 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend56[32] = {0x2b,0xb7,0x1c,0x68,0x20,0x97,0x79,0x8c,0x8c,0xd3,0xe4,0x18,0xed,0x41,0x42,0xba,0xe9,0x72,0x9f,0x3f,0x0c,0x89,0xc0,0x01,0x7c,0x4e,0xa6,0x03,0x49,0x44,0xf2,0xce};
    static std::uint32_t divisor56     = 1781838706;
    static std::uint8_t  quotient56[32]    = {0x00,0x00,0x00,0x00,0x69,0x5f,0x33,0x38,0x1c,0xf2,0xd6,0xed,0x2c,0x08,0x37,0x9b,0x3c,0xd1,0x25,0xa8,0xe9,0x77,0x1e,0x66,0xed,0x78,0xc5,0x0f,0x21,0x01,0x7a,0xeb};
    static std::uint32_t remainder56      = 1206773032;
    uint256_from_bytes(dividend, dividend56);
    remainder = uint256_div_uint32(quotient, dividend, divisor56);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient56, quotient_data, 32) != 0 || remainder56 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend57[32] = {0xa7,0x1f,0x11,0xb2,0xf9,0xee,0x8b,0xc8,0xbd,0x1e,0x69,0x12,0xbd,0x31,0x3b,0xee,0x41,0x78,0x5b,0xc6,0x4c,0x3a,0xc6,0xfc,0x48,0x20,0x82,0x31,0x57,0xfa,0x49,0xe5};
    static std::uint32_t divisor57     = 1744655514;
    static std::uint8_t  quotient57[32]    = {0x00,0x00,0x00,0x01,0x9b,0x6a,0xbb,0x0b,0x74,0xe4,0x07,0xe6,0xa0,0x22,0x1e,0x03,0xda,0xbe,0xb6,0x54,0x3f,0xc4,0x61,0x28,0xf5,0x66,0xce,0xd7,0x02,0x4b,0x38,0x91};
    static std::uint32_t remainder57      = 165523115;
    uint256_from_bytes(dividend, dividend57);
    remainder = uint256_div_uint32(quotient, dividend, divisor57);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient57, quotient_data, 32) != 0 || remainder57 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend58[32] = {0x1e,0xa7,0x72,0x28,0x64,0xf5,0x49,0x69,0xab,0x3b,0x74,0xfe,0x8e,0xac,0xa2,0x88,0x7b,0xb1,0xd1,0x24,0x4d,0x03,0x9b,0x72,0x3d,0x19,0x26,0xac,0xa7,0xef,0x4f,0x5d};
    static std::uint32_t divisor58     = 2762544593;
    static std::uint8_t  quotient58[32]    = {0x00,0x00,0x00,0x00,0x2f,0xa8,0x89,0x1c,0x53,0x62,0x4e,0xe7,0xb5,0xe8,0x7f,0x17,0x87,0xa7,0xa3,0x2a,0x90,0x28,0x81,0x4a,0xd2,0xa5,0x3c,0xe0,0x09,0xd6,0xc1,0xda};
    static std::uint32_t remainder58      = 1623861859;
    uint256_from_bytes(dividend, dividend58);
    remainder = uint256_div_uint32(quotient, dividend, divisor58);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient58, quotient_data, 32) != 0 || remainder58 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend59[32] = {0x8c,0xe6,0x21,0xef,0x7f,0x40,0x5b,0xc8,0xcf,0xd3,0xdd,0x72,0xe7,0xec,0xfd,0x0c,0x80,0x27,0xa2,0xa2,0x35,0x37,0x22,0x35,0x13,0x3e,0x61,0x53,0x29,0x62,0x59,0xc8};
    static std::uint32_t divisor59     = 1945560382;
    static std::uint8_t  quotient59[32]    = {0x00,0x00,0x00,0x01,0x37,0x0b,0x76,0xd7,0x4a,0x1a,0x3c,0x6d,0xce,0xcd,0x6b,0xe3,0xed,0x63,0xd9,0x25,0xe5,0xf9,0xa8,0xcc,0xbf,0x74,0x08,0x96,0x9d,0x72,0x24,0x56};
    static std::uint32_t remainder59      = 1620614900;
    uint256_from_bytes(dividend, dividend59);
    remainder = uint256_div_uint32(quotient, dividend, divisor59);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient59, quotient_data, 32) != 0 || remainder59 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend60[32] = {0x8c,0x3b,0xa8,0x59,0x23,0xbc,0x91,0x52,0x6d,0x6b,0x98,0x7a,0x73,0x30,0x9b,0x95,0xc2,0x5e,0x11,0x4f,0xff,0x18,0xfe,0x33,0x55,0x34,0xa0,0x34,0xe8,0x00,0x9d,0x90};
    static std::uint32_t divisor60     = 1048339816;
    static std::uint8_t  quotient60[32]    = {0x00,0x00,0x00,0x02,0x3e,0x86,0x20,0x36,0x95,0x0f,0x77,0x1d,0x35,0xa8,0x04,0x5f,0xfa,0xb3,0xbc,0x62,0x12,0xac,0x96,0xbb,0x14,0x3a,0x6f,0x21,0xfc,0x87,0x3a,0xe8};
    static std::uint32_t remainder60      = 1047734096;
    uint256_from_bytes(dividend, dividend60);
    remainder = uint256_div_uint32(quotient, dividend, divisor60);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient60, quotient_data, 32) != 0 || remainder60 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend61[32] = {0x5e,0x49,0x42,0x2a,0x3d,0x37,0x66,0x42,0x51,0xbc,0xd7,0x7a,0x17,0x51,0xf5,0x79,0x8e,0x4d,0xc3,0xa3,0x57,0x8a,0x60,0xd8,0x2c,0xb8,0xd1,0x4c,0x17,0x39,0x10,0xe3};
    static std::uint32_t divisor61     = 3476168036;
    static std::uint8_t  quotient61[32]    = {0x00,0x00,0x00,0x00,0x74,0x7e,0xb4,0x9d,0x30,0xec,0xcf,0xd8,0x29,0x64,0x46,0x33,0xc2,0x46,0x28,0x40,0x22,0x65,0x7b,0x82,0x35,0xc4,0x7d,0x8a,0xff,0x80,0xc6,0xfe};
    static std::uint32_t remainder61      = 1925484459;
    uint256_from_bytes(dividend, dividend61);
    remainder = uint256_div_uint32(quotient, dividend, divisor61);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient61, quotient_data, 32) != 0 || remainder61 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend62[32] = {0x62,0x01,0xa9,0xd3,0x69,0xac,0x0f,0x03,0xde,0xe0,0xa8,0x43,0xbf,0xe9,0x8f,0x8c,0x05,0x24,0x13,0x7f,0xe3,0x22,0xe9,0x6d,0x33,0xbf,0x91,0x57,0x91,0xd2,0x77,0xf2};
    static std::uint32_t divisor62     = 3203360764;
    static std::uint8_t  quotient62[32]    = {0x00,0x00,0x00,0x00,0x83,0x67,0x72,0x5b,0x30,0x19,0x75,0x65,0xf7,0x17,0x6c,0x9b,0xe3,0x31,0x9c,0xca,0x27,0xbb,0xb2,0x3c,0x70,0x26,0x52,0x3c,0x1c,0x0d,0xcc,0xcd};
    static std::uint32_t remainder62      = 225665830;
    uint256_from_bytes(dividend, dividend62);
    remainder = uint256_div_uint32(quotient, dividend, divisor62);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient62, quotient_data, 32) != 0 || remainder62 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend63[32] = {0x7f,0x86,0x7d,0x5f,0x0f,0xe3,0x21,0xec,0xc0,0x8a,0x58,0xd7,0x56,0x94,0x7a,0x7a,0x45,0x2e,0x70,0x4d,0x60,0x7a,0x47,0x32,0x35,0xc2,0xe2,0x29,0x86,0x2f,0xe2,0x31};
    static std::uint32_t divisor63     = 2466517103;
    static std::uint8_t  quotient63[32]    = {0x00,0x00,0x00,0x00,0xde,0x0f,0x9c,0x83,0x3b,0xb5,0x59,0x9c,0xf5,0x4c,0x5c,0xc0,0xe1,0xcc,0xef,0x82,0x49,0xb2,0x25,0x4d,0xda,0xe2,0x13,0x8c,0xd5,0x02,0x39,0x08};
    static std::uint32_t remainder63      = 2324211641;
    uint256_from_bytes(dividend, dividend63);
    remainder = uint256_div_uint32(quotient, dividend, divisor63);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient63, quotient_data, 32) != 0 || remainder63 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend64[32] = {0xf7,0xd1,0x7e,0xbd,0xdf,0x75,0xc8,0x83,0xd0,0x78,0x84,0xb7,0xd9,0x43,0x55,0x41,0x4f,0xe0,0x48,0x02,0xf4,0x35,0xa5,0x73,0x6e,0x8c,0xd9,0x4e,0x72,0x23,0xc6,0x8a};
    static std::uint32_t divisor64     = 546521803;
    static std::uint8_t  quotient64[32]    = {0x00,0x00,0x00,0x07,0x9b,0x89,0x94,0xdc,0xb2,0x0c,0xd1,0xf6,0x0f,0x0f,0x86,0x6d,0xb2,0x6f,0xef,0xe9,0x91,0x23,0xd6,0x6b,0xfc,0x08,0x70,0x00,0xb4,0xa1,0x0d,0x97};
    static std::uint32_t remainder64      = 54006221;
    uint256_from_bytes(dividend, dividend64);
    remainder = uint256_div_uint32(quotient, dividend, divisor64);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient64, quotient_data, 32) != 0 || remainder64 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend65[32] = {0x39,0x4a,0xfb,0xe9,0x1b,0xea,0x70,0x5e,0xc8,0x79,0xb6,0x63,0x3f,0x9b,0x6b,0xb2,0x72,0xee,0x6a,0x2e,0xf8,0xe4,0xcb,0x5c,0x77,0xd8,0xc5,0x69,0xda,0xff,0x9a,0x0b};
    static std::uint32_t divisor65     = 653128126;
    static std::uint8_t  quotient65[32]    = {0x00,0x00,0x00,0x01,0x78,0xc2,0x03,0x83,0xee,0xf5,0x3f,0xa5,0xeb,0x53,0xa3,0x89,0xca,0x30,0x25,0x2c,0xc8,0x5f,0x6b,0xa0,0x45,0xe7,0x32,0xf1,0x01,0x35,0xa0,0x0f};
    static std::uint32_t remainder65      = 295809001;
    uint256_from_bytes(dividend, dividend65);
    remainder = uint256_div_uint32(quotient, dividend, divisor65);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient65, quotient_data, 32) != 0 || remainder65 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend66[32] = {0x0a,0x1f,0xb4,0x3b,0xc6,0xe0,0x67,0x3a,0x8d,0x2f,0x29,0xe7,0x15,0xc2,0xc8,0x1a,0x75,0x13,0x41,0x07,0xe5,0x17,0x4e,0xbd,0xc3,0xc9,0xf7,0xe3,0xd8,0xb4,0xc8,0x31};
    static std::uint32_t divisor66     = 3359947006;
    static std::uint8_t  quotient66[32]    = {0x00,0x00,0x00,0x00,0x0c,0xf0,0xef,0x36,0x0c,0x34,0x71,0xca,0xe8,0x46,0x0b,0x8e,0x59,0xc9,0x27,0x8d,0x2a,0xf7,0x36,0x4b,0xb9,0x2d,0xda,0x06,0x9b,0xf2,0x86,0x2d};
    static std::uint32_t remainder66      = 28266379;
    uint256_from_bytes(dividend, dividend66);
    remainder = uint256_div_uint32(quotient, dividend, divisor66);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient66, quotient_data, 32) != 0 || remainder66 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend67[32] = {0xc3,0x8b,0x48,0xa2,0xb2,0xd6,0x43,0xa2,0x6f,0xfb,0x72,0x6a,0xa2,0xe3,0xf9,0x3a,0x87,0x3b,0x99,0x03,0x40,0x75,0x91,0x6e,0xa0,0x60,0x84,0x6c,0x20,0xc2,0x6f,0x71};
    static std::uint32_t divisor67     = 427112114;
    static std::uint8_t  quotient67[32]    = {0x00,0x00,0x00,0x07,0xae,0x5b,0xb4,0x44,0xf1,0x0c,0x68,0x43,0x39,0xbc,0x42,0x1a,0x52,0x1d,0xfe,0xf1,0x87,0x4d,0x49,0xd8,0x4a,0xa8,0xba,0x29,0x65,0x15,0xf8,0x95};
    static std::uint32_t remainder67      = 200485335;
    uint256_from_bytes(dividend, dividend67);
    remainder = uint256_div_uint32(quotient, dividend, divisor67);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient67, quotient_data, 32) != 0 || remainder67 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend68[32] = {0x42,0xc9,0x27,0xb9,0x63,0x59,0x56,0xbe,0x31,0x13,0x5d,0xe9,0x95,0x38,0x57,0xd7,0xf1,0x8b,0xde,0x0e,0x86,0x41,0x7b,0x60,0x4c,0xe3,0xb0,0xcc,0x12,0x02,0x95,0x2f};
    static std::uint32_t divisor68     = 3395116670;
    static std::uint8_t  quotient68[32]    = {0x00,0x00,0x00,0x00,0x54,0x7c,0xa1,0x48,0xcf,0x00,0x07,0x76,0x9a,0xe9,0x05,0x12,0xec,0xba,0x2b,0x0e,0x7c,0x00,0x64,0x70,0x9d,0x7e,0x13,0x69,0xbe,0x78,0x8a,0x2a};
    static std::uint32_t remainder68      = 3132172419;
    uint256_from_bytes(dividend, dividend68);
    remainder = uint256_div_uint32(quotient, dividend, divisor68);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient68, quotient_data, 32) != 0 || remainder68 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend69[32] = {0x0e,0x28,0xb6,0x4f,0x4e,0xb1,0x9f,0xca,0xa6,0x4f,0x76,0x13,0xb4,0x64,0x2e,0xa4,0x69,0x6c,0x63,0xd6,0xf5,0xea,0xd0,0x65,0x07,0x7e,0xf3,0x2a,0x3f,0x3f,0x37,0xea};
    static std::uint32_t divisor69     = 833718555;
    static std::uint8_t  quotient69[32]    = {0x00,0x00,0x00,0x00,0x48,0xf0,0xfe,0x05,0x4c,0xa7,0x2d,0x0f,0x62,0xe1,0x38,0x86,0x18,0x6b,0x7d,0xf6,0xb2,0x33,0x96,0x66,0x40,0x38,0x92,0xf2,0x50,0x35,0xe8,0x07};
    static std::uint32_t remainder69      = 747438125;
    uint256_from_bytes(dividend, dividend69);
    remainder = uint256_div_uint32(quotient, dividend, divisor69);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient69, quotient_data, 32) != 0 || remainder69 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend70[32] = {0xe3,0xab,0x62,0x83,0xc2,0xae,0x35,0xd2,0x43,0xd8,0x7a,0x97,0x38,0xb0,0x79,0xe1,0x77,0x11,0xb7,0x57,0x3b,0x16,0x49,0x43,0x31,0xa5,0x9c,0x4a,0xd1,0xeb,0xd0,0x86};
    static std::uint32_t divisor70     = 468186064;
    static std::uint8_t  quotient70[32]    = {0x00,0x00,0x00,0x08,0x28,0x8e,0x67,0x46,0x99,0xf9,0xc6,0x56,0x49,0xbc,0x91,0x69,0x4f,0xdc,0xee,0x78,0x3f,0x80,0x2c,0x9e,0x6e,0x4c,0xfa,0x1a,0xcc,0x08,0x21,0x4e};
    static std::uint32_t remainder70      = 206681894;
    uint256_from_bytes(dividend, dividend70);
    remainder = uint256_div_uint32(quotient, dividend, divisor70);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient70, quotient_data, 32) != 0 || remainder70 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend71[32] = {0x7c,0x2c,0x6a,0x87,0x39,0x2b,0xc5,0x52,0xe5,0x7f,0x76,0x91,0x2f,0xf3,0xc2,0x3c,0x9c,0x2f,0x67,0x23,0x7e,0xea,0x6f,0xe1,0x9f,0xa4,0x0d,0xd6,0xf3,0xb1,0x7a,0xf0};
    static std::uint32_t divisor71     = 3910121042;
    static std::uint8_t  quotient71[32]    = {0x00,0x00,0x00,0x00,0x88,0x65,0x21,0x78,0x80,0x76,0x7f,0xf2,0xd2,0x3d,0x03,0x04,0xb7,0x78,0x84,0x18,0xa2,0xdb,0xc7,0x83,0x2d,0x09,0x7c,0x79,0x08,0xcf,0x3d,0x28};
    static std::uint32_t remainder71      = 3464328224;
    uint256_from_bytes(dividend, dividend71);
    remainder = uint256_div_uint32(quotient, dividend, divisor71);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient71, quotient_data, 32) != 0 || remainder71 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend72[32] = {0x0d,0xea,0x6e,0x4e,0x64,0xb9,0xcb,0x1c,0xec,0x03,0x2e,0x6b,0x25,0x79,0x5c,0x18,0x98,0x44,0xf4,0x76,0xf2,0xe2,0x05,0x4d,0x0e,0x71,0x59,0x7a,0xaa,0x50,0xb9,0x6f};
    static std::uint32_t divisor72     = 101484549;
    static std::uint8_t  quotient72[32]    = {0x00,0x00,0x00,0x02,0x4c,0xef,0x07,0xec,0x21,0x45,0xc2,0x59,0xb3,0x0e,0x7a,0x34,0x77,0xe9,0xbc,0x35,0xb3,0x39,0x95,0x79,0x9b,0xb3,0x22,0xb4,0x2d,0x4e,0x09,0xf9};
    static std::uint32_t remainder72      = 80887698;
    uint256_from_bytes(dividend, dividend72);
    remainder = uint256_div_uint32(quotient, dividend, divisor72);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient72, quotient_data, 32) != 0 || remainder72 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend73[32] = {0x2f,0x21,0x7e,0x72,0x0f,0x65,0x06,0x38,0xb5,0xb9,0x4a,0xf3,0x0d,0x45,0x6b,0xe0,0x6a,0x56,0xaa,0xc3,0x24,0x54,0x48,0xc8,0x98,0x9b,0xc9,0xdc,0xf9,0x5f,0xe8,0xa0};
    static std::uint32_t divisor73     = 1931197506;
    static std::uint8_t  quotient73[32]    = {0x00,0x00,0x00,0x00,0x68,0xd1,0x8f,0x0d,0x7a,0x31,0xc5,0x96,0xf6,0xcb,0x98,0x13,0xbf,0x7b,0x95,0x70,0x7c,0x5e,0x6b,0xe6,0x15,0x1b,0x52,0x8d,0x18,0x9e,0xb3,0x93};
    static std::uint32_t remainder73      = 454338746;
    uint256_from_bytes(dividend, dividend73);
    remainder = uint256_div_uint32(quotient, dividend, divisor73);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient73, quotient_data, 32) != 0 || remainder73 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend74[32] = {0xbf,0x0e,0x11,0xe0,0x86,0x59,0x22,0x43,0xef,0x95,0xee,0xe8,0xa7,0x08,0x28,0xa7,0x2f,0x7d,0xba,0x08,0x30,0xd0,0xa2,0xb8,0x54,0x49,0x40,0xe1,0x2a,0x66,0xf9,0x13};
    static std::uint32_t divisor74     = 136982350;
    static std::uint8_t  quotient74[32]    = {0x00,0x00,0x00,0x17,0x66,0x5e,0x6e,0xba,0x94,0x59,0xae,0xf2,0x2d,0x18,0x99,0xc5,0x5d,0x96,0xf2,0x46,0xad,0x8e,0xa7,0x55,0x54,0x25,0xc2,0x7b,0x3b,0x73,0xcd,0x63};
    static std::uint32_t remainder74      = 2832361;
    uint256_from_bytes(dividend, dividend74);
    remainder = uint256_div_uint32(quotient, dividend, divisor74);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient74, quotient_data, 32) != 0 || remainder74 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend75[32] = {0x54,0xea,0x20,0x61,0xfc,0x27,0xd6,0x83,0x5f,0xb6,0xd6,0x25,0xd6,0xd1,0x06,0xfb,0x60,0xed,0x33,0xa0,0xb9,0xb2,0x53,0xe3,0xaa,0x18,0x13,0x45,0x4f,0xd3,0xe7,0x58};
    static std::uint32_t divisor75     = 726970232;
    static std::uint8_t  quotient75[32]    = {0x00,0x00,0x00,0x01,0xf5,0xad,0xa9,0xe4,0x63,0x44,0x7d,0xc3,0x03,0xde,0x19,0x17,0x9f,0x93,0x62,0x03,0xf7,0x49,0xd9,0x41,0xb8,0x8e,0xe8,0x5a,0x9d,0xfc,0x47,0x8a};
    static std::uint32_t remainder75      = 627247272;
    uint256_from_bytes(dividend, dividend75);
    remainder = uint256_div_uint32(quotient, dividend, divisor75);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient75, quotient_data, 32) != 0 || remainder75 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend76[32] = {0x79,0x34,0xf0,0xb8,0xb4,0x8b,0xb0,0x75,0x0c,0x9c,0x20,0xef,0x16,0x77,0x74,0xef,0x6e,0xb4,0xff,0xf8,0xcd,0xce,0xc4,0x08,0xd2,0x6f,0x1d,0x76,0x4f,0x06,0xe9,0x5a};
    static std::uint32_t divisor76     = 1600796122;
    static std::uint8_t  quotient76[32]    = {0x00,0x00,0x00,0x01,0x45,0x33,0x40,0xeb,0x36,0x13,0xb9,0x64,0x1d,0x94,0xf7,0x92,0xfb,0xf2,0x34,0x10,0xa9,0x2b,0x90,0xc4,0x21,0xc1,0xc4,0x2a,0x67,0x19,0xdd,0xc5};
    static std::uint32_t remainder76      = 964970136;
    uint256_from_bytes(dividend, dividend76);
    remainder = uint256_div_uint32(quotient, dividend, divisor76);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient76, quotient_data, 32) != 0 || remainder76 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend77[32] = {0xe5,0xa1,0x5b,0x79,0xbc,0xc0,0xfd,0x98,0x5d,0x3f,0x69,0xce,0x52,0xc4,0x64,0x1b,0x31,0x6a,0x2a,0x12,0x72,0x43,0xd4,0x7c,0xeb,0x64,0xc5,0xc4,0x8a,0xa1,0xa5,0x9c};
    static std::uint32_t divisor77     = 130060445;
    static std::uint8_t  quotient77[32]    = {0x00,0x00,0x00,0x1d,0x9f,0x0c,0x5d,0xf7,0x65,0x2f,0xfe,0x7d,0xe4,0x53,0x60,0x4f,0x27,0xf9,0x6d,0xda,0xcb,0x30,0x97,0xce,0x76,0x03,0x28,0xdf,0x8b,0x38,0x90,0x0b};
    static std::uint32_t remainder77      = 44768989;
    uint256_from_bytes(dividend, dividend77);
    remainder = uint256_div_uint32(quotient, dividend, divisor77);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient77, quotient_data, 32) != 0 || remainder77 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend78[32] = {0x0a,0x68,0x01,0x3d,0x67,0x9f,0x2d,0x9e,0xc4,0x44,0x5a,0xae,0xa0,0x1a,0xc2,0x3a,0xcf,0xd3,0xbb,0x74,0x3f,0x7d,0xc8,0x6b,0x69,0x2a,0x4f,0x0e,0xa1,0xb4,0x9b,0xf7};
    static std::uint32_t divisor78     = 149698459;
    static std::uint8_t  quotient78[32]    = {0x00,0x00,0x00,0x01,0x2a,0x90,0x68,0x6b,0x1f,0xef,0xf5,0xe6,0x03,0x5e,0x57,0x1f,0xf9,0x4a,0x58,0xc2,0x6f,0xe2,0x60,0x0a,0x9f,0xfb,0xb2,0x9a,0x45,0xb8,0x1e,0x05};
    static std::uint32_t remainder78      = 137059312;
    uint256_from_bytes(dividend, dividend78);
    remainder = uint256_div_uint32(quotient, dividend, divisor78);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient78, quotient_data, 32) != 0 || remainder78 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend79[32] = {0xbf,0x4e,0x30,0x2c,0x31,0xe7,0xae,0xd1,0x41,0xcb,0xcc,0x3a,0x0f,0xdf,0x7c,0xc6,0xeb,0x8a,0x25,0xfc,0xcd,0xa7,0x90,0x77,0x10,0x05,0x3d,0x2c,0x76,0xcc,0x05,0x73};
    static std::uint32_t divisor79     = 3859250554;
    static std::uint8_t  quotient79[32]    = {0x00,0x00,0x00,0x00,0xd4,0xe7,0x77,0xa4,0x1b,0x7b,0x4e,0xd3,0x40,0x4c,0x0c,0x54,0x89,0x3c,0xc0,0x5a,0xd1,0x74,0x35,0xb6,0x49,0x87,0xbc,0x14,0xb4,0x3c,0xbc,0xd0};
    static std::uint32_t remainder79      = 3757603411;
    uint256_from_bytes(dividend, dividend79);
    remainder = uint256_div_uint32(quotient, dividend, divisor79);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient79, quotient_data, 32) != 0 || remainder79 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend80[32] = {0x9d,0xf2,0x4d,0x5e,0xf4,0x29,0xc6,0x22,0xf5,0x2b,0x25,0x49,0x55,0xc0,0xa7,0x4d,0x45,0xb6,0x69,0xf7,0x5c,0xeb,0xe2,0x13,0x56,0xcd,0x42,0xd2,0x9b,0x09,0xab,0x55};
    static std::uint32_t divisor80     = 1126022208;
    static std::uint8_t  quotient80[32]    = {0x00,0x00,0x00,0x02,0x5a,0x73,0xde,0x7e,0x42,0xdd,0x0d,0x18,0x8b,0x7e,0x42,0x82,0xb1,0xd1,0xc7,0xbf,0x8c,0xe8,0x7b,0x46,0x77,0x8c,0x80,0xf3,0x3e,0xc0,0x1f,0x32};
    static std::uint32_t remainder80      = 896476885;
    uint256_from_bytes(dividend, dividend80);
    remainder = uint256_div_uint32(quotient, dividend, divisor80);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient80, quotient_data, 32) != 0 || remainder80 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend81[32] = {0x10,0xb9,0x9a,0xc9,0xf1,0x78,0xd7,0x7f,0xf2,0x4d,0x04,0xfd,0xa2,0x4c,0x84,0x07,0xce,0x3f,0xa0,0x28,0xea,0x9d,0x18,0xb2,0x98,0x77,0x27,0x90,0xc1,0x72,0x6f,0x06};
    static std::uint32_t divisor81     = 3547721714;
    static std::uint8_t  quotient81[32]    = {0x00,0x00,0x00,0x00,0x14,0x3f,0x6c,0xfa,0xe1,0xcd,0x87,0x65,0x96,0xa9,0x0a,0xf9,0x2e,0x8e,0x3b,0x75,0x7c,0x77,0xed,0xe7,0x33,0x87,0xa6,0x43,0x0a,0x28,0xf3,0xda};
    static std::uint32_t remainder81      = 3396429042;
    uint256_from_bytes(dividend, dividend81);
    remainder = uint256_div_uint32(quotient, dividend, divisor81);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient81, quotient_data, 32) != 0 || remainder81 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend82[32] = {0xc6,0xbf,0x4f,0xa2,0xf4,0x33,0x7b,0xd1,0x77,0x3a,0xfe,0x02,0xf4,0xef,0x61,0x42,0xb7,0x2f,0xac,0x4a,0x79,0xa5,0xfd,0x62,0x1b,0x75,0x7b,0x20,0x3b,0xde,0xa8,0xc3};
    static std::uint32_t divisor82     = 3392160281;
    static std::uint8_t  quotient82[32]    = {0x00,0x00,0x00,0x00,0xfb,0xa4,0x97,0xd4,0x3f,0x9a,0xa0,0x92,0x19,0xc6,0xbb,0x5b,0x57,0x91,0xe3,0x5e,0xf2,0xb7,0x1a,0xc1,0x54,0x6d,0xe1,0xc0,0xe4,0x92,0xd0,0xe5};
    static std::uint32_t remainder82      = 851261542;
    uint256_from_bytes(dividend, dividend82);
    remainder = uint256_div_uint32(quotient, dividend, divisor82);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient82, quotient_data, 32) != 0 || remainder82 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend83[32] = {0x7f,0x1d,0x49,0x0e,0xed,0x97,0xec,0x76,0x21,0xf9,0x1a,0x99,0x7e,0x54,0x4d,0x56,0xd0,0x96,0xbf,0xd6,0x6e,0x10,0x6c,0x0e,0xe9,0xde,0x04,0x79,0x40,0x44,0x9a,0xa0};
    static std::uint32_t divisor83     = 37388451;
    static std::uint8_t  quotient83[32]    = {0x00,0x00,0x00,0x39,0x0a,0x29,0x2a,0x9c,0x54,0x44,0x9f,0x10,0x81,0x27,0xc0,0xd8,0x4b,0x9e,0x01,0xa5,0x59,0x63,0x31,0xd0,0xd7,0x41,0xc6,0xf2,0x4e,0xae,0xa4,0x4d};
    static std::uint32_t remainder83      = 24739225;
    uint256_from_bytes(dividend, dividend83);
    remainder = uint256_div_uint32(quotient, dividend, divisor83);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient83, quotient_data, 32) != 0 || remainder83 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend84[32] = {0x68,0x62,0xbf,0x79,0x3f,0x4f,0x8b,0x9d,0x28,0xf1,0xa8,0x1b,0xc0,0xbd,0x1d,0x84,0x64,0x45,0x7e,0xa4,0x32,0x83,0x06,0x89,0x83,0x0a,0xe1,0x9e,0x14,0x3a,0x51,0x80};
    static std::uint32_t divisor84     = 2789778829;
    static std::uint8_t  quotient84[32]    = {0x00,0x00,0x00,0x00,0xa0,0xb4,0xa7,0xb1,0x8d,0x8d,0xc6,0x7e,0x71,0x21,0xf3,0xa9,0xae,0xad,0x5d,0xa2,0x18,0x6f,0xec,0x28,0x60,0x13,0xe8,0x85,0x30,0xf7,0x0c,0xab};
    static std::uint32_t remainder84      = 1860575313;
    uint256_from_bytes(dividend, dividend84);
    remainder = uint256_div_uint32(quotient, dividend, divisor84);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient84, quotient_data, 32) != 0 || remainder84 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend85[32] = {0x18,0xaf,0x26,0x6c,0x35,0x55,0xd6,0xae,0x15,0x86,0x6f,0xfb,0x9f,0xe5,0xe3,0x99,0x43,0xcf,0xea,0xdf,0x12,0x79,0x68,0x8c,0xfc,0xe2,0x05,0xcd,0x1a,0xef,0xca,0x62};
    static std::uint32_t divisor85     = 2140934946;
    static std::uint8_t  quotient85[32]    = {0x00,0x00,0x00,0x00,0x31,0x84,0xf5,0x51,0x2e,0x5c,0xaf,0x53,0x11,0x4d,0x7d,0xdf,0x7d,0x20,0xec,0xfb,0x8c,0x39,0x18,0xb7,0xbb,0xa7,0x95,0x5d,0xf2,0x79,0xdb,0xdb};
    static std::uint32_t remainder85      = 1023104588;
    uint256_from_bytes(dividend, dividend85);
    remainder = uint256_div_uint32(quotient, dividend, divisor85);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient85, quotient_data, 32) != 0 || remainder85 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend86[32] = {0x6a,0xb6,0x11,0x4f,0x22,0x07,0xc6,0xc0,0x3b,0xf4,0x49,0xfd,0x2c,0x56,0x4d,0x56,0x72,0x6c,0x2c,0x95,0xf8,0xdc,0xa3,0x09,0xb5,0xb3,0x90,0x23,0xfd,0x09,0xe3,0x7c};
    static std::uint32_t divisor86     = 2664201056;
    static std::uint8_t  quotient86[32]    = {0x00,0x00,0x00,0x00,0xac,0x07,0x8b,0xf8,0xa3,0x58,0x8f,0x52,0xfc,0x5b,0xa9,0x70,0x91,0x94,0x86,0x31,0x82,0xe8,0xe6,0xee,0x1b,0x43,0xe6,0xf2,0xc0,0x89,0x8c,0xf2};
    static std::uint32_t remainder86      = 98878140;
    uint256_from_bytes(dividend, dividend86);
    remainder = uint256_div_uint32(quotient, dividend, divisor86);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient86, quotient_data, 32) != 0 || remainder86 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend87[32] = {0x44,0x85,0xc0,0x4f,0x91,0x1f,0x52,0xdc,0x47,0x86,0x8e,0x4a,0x4b,0x35,0x4e,0x93,0x4b,0x3e,0x90,0xb7,0xd7,0x43,0x55,0x71,0xc7,0x9d,0xbc,0x12,0x1f,0x04,0xa6,0xff};
    static std::uint32_t divisor87     = 1091164375;
    static std::uint8_t  quotient87[32]    = {0x00,0x00,0x00,0x01,0x0d,0xb6,0xa7,0x1f,0xbf,0x64,0x3b,0xd0,0x35,0x65,0x7d,0x44,0x95,0x23,0x69,0xee,0x06,0xea,0x6d,0x3c,0xa1,0xcb,0xcc,0x2e,0x54,0xe1,0x31,0xb9};
    static std::uint32_t remainder87      = 460246176;
    uint256_from_bytes(dividend, dividend87);
    remainder = uint256_div_uint32(quotient, dividend, divisor87);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient87, quotient_data, 32) != 0 || remainder87 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend88[32] = {0x3c,0x49,0xfd,0xbd,0x3e,0xce,0x9f,0x2c,0x2f,0x8c,0x6c,0x08,0x3f,0x57,0x83,0xea,0x70,0x7c,0x5f,0x3d,0x32,0xfe,0x1f,0x36,0x42,0xa5,0x51,0x62,0xbc,0xf1,0xfc,0xb5};
    static std::uint32_t divisor88     = 1208406640;
    static std::uint8_t  quotient88[32]    = {0x00,0x00,0x00,0x00,0xd6,0x48,0x1c,0x1b,0x53,0xc6,0xea,0x11,0x55,0xb8,0x22,0xe6,0xad,0x51,0x9f,0xaa,0x5b,0xc2,0x34,0xec,0x75,0x96,0x31,0x01,0xa6,0x09,0x5d,0x4f};
    static std::uint32_t remainder88      = 41180197;
    uint256_from_bytes(dividend, dividend88);
    remainder = uint256_div_uint32(quotient, dividend, divisor88);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient88, quotient_data, 32) != 0 || remainder88 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend89[32] = {0xa7,0x40,0x68,0xb2,0x19,0xbd,0x26,0x40,0xce,0xf6,0x1d,0x03,0xa6,0x4e,0xd9,0x96,0x3b,0x3b,0xc8,0x13,0x86,0xbc,0x2b,0x99,0x81,0xe0,0x04,0xfb,0x3e,0xf6,0x87,0x56};
    static std::uint32_t divisor89     = 4256122132;
    static std::uint8_t  quotient89[32]    = {0x00,0x00,0x00,0x00,0xa8,0xc7,0x30,0x8e,0xb4,0xa7,0x5c,0x15,0xe4,0xc7,0xf7,0xd8,0xfe,0x87,0x98,0x1f,0x2c,0xda,0x64,0x6f,0xcf,0x9a,0x13,0xd0,0xa8,0xd6,0x53,0xa4};
    static std::uint32_t remainder89      = 143706758;
    uint256_from_bytes(dividend, dividend89);
    remainder = uint256_div_uint32(quotient, dividend, divisor89);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient89, quotient_data, 32) != 0 || remainder89 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend90[32] = {0xd7,0x2e,0xb3,0xa1,0x3b,0x2a,0x42,0x1a,0xd1,0xb0,0xb7,0x0b,0xe2,0x00,0xd2,0x18,0x79,0x8a,0x0d,0x59,0x01,0x26,0x64,0xf6,0x1a,0x32,0x75,0x37,0x09,0x7a,0x59,0x42};
    static std::uint32_t divisor90     = 3927213115;
    static std::uint8_t  quotient90[32]    = {0x00,0x00,0x00,0x00,0xeb,0x55,0x28,0xf0,0x8e,0xea,0xcc,0x2c,0xb4,0x4d,0x27,0x1b,0xe3,0x6b,0xef,0x8e,0xfa,0x7f,0x81,0x64,0x03,0x89,0x8c,0x68,0x5c,0xee,0x86,0x23};
    static std::uint32_t remainder90      = 681272113;
    uint256_from_bytes(dividend, dividend90);
    remainder = uint256_div_uint32(quotient, dividend, divisor90);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient90, quotient_data, 32) != 0 || remainder90 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend91[32] = {0xf2,0x19,0x88,0x25,0xaa,0x2d,0x6c,0x38,0xc7,0x1c,0x58,0x8c,0xc6,0x66,0x48,0x43,0x42,0x8b,0xf7,0x73,0x9a,0x60,0xf9,0x19,0x72,0xf9,0x20,0x26,0x2d,0x81,0x9d,0x38};
    static std::uint32_t divisor91     = 454321911;
    static std::uint8_t  quotient91[32]    = {0x00,0x00,0x00,0x08,0xf0,0xb5,0x63,0x03,0xe7,0x74,0x27,0x72,0xb7,0x90,0x75,0xf5,0x79,0xbf,0x12,0xc8,0xf6,0x93,0x07,0xcb,0xe8,0x1d,0x22,0x28,0x01,0x3a,0x2a,0xd5};
    static std::uint32_t remainder91      = 28142517;
    uint256_from_bytes(dividend, dividend91);
    remainder = uint256_div_uint32(quotient, dividend, divisor91);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient91, quotient_data, 32) != 0 || remainder91 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend92[32] = {0x5e,0x63,0xaf,0x16,0x09,0x96,0x9e,0x7c,0x37,0xb7,0x9c,0x48,0x59,0x85,0xea,0x3f,0x9e,0xb4,0xe9,0x2e,0xb5,0xaf,0x4c,0x8a,0x98,0x9d,0x18,0x1c,0xa3,0x30,0x66,0xbd};
    static std::uint32_t divisor92     = 607177326;
    static std::uint8_t  quotient92[32]    = {0x00,0x00,0x00,0x02,0x9b,0xad,0xbc,0xcb,0xc5,0x61,0x6a,0x12,0xd9,0xc9,0x67,0x9f,0x6c,0xfa,0x06,0x3b,0x4f,0xe6,0xc2,0xb7,0x58,0xf3,0xc6,0x22,0xa3,0xc6,0x85,0x84};
    static std::uint32_t remainder92      = 97050629;
    uint256_from_bytes(dividend, dividend92);
    remainder = uint256_div_uint32(quotient, dividend, divisor92);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient92, quotient_data, 32) != 0 || remainder92 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend93[32] = {0x5f,0x2e,0xe4,0x0d,0xad,0xa6,0x5c,0xc4,0x68,0xb3,0xe3,0xaa,0x53,0xc6,0x9b,0x0a,0xd1,0x9f,0x0b,0xe9,0x02,0xe9,0xc9,0xfb,0xd0,0x93,0x0b,0x64,0x34,0x14,0xc2,0xdc};
    static std::uint32_t divisor93     = 2667233939;
    static std::uint8_t  quotient93[32]    = {0x00,0x00,0x00,0x00,0x99,0x45,0x47,0x23,0x27,0xe7,0x8a,0x16,0xf8,0xfb,0x34,0x9e,0x25,0x9c,0xdd,0x3a,0xd1,0xc0,0x2a,0xf7,0xdd,0xe3,0xca,0x9d,0x06,0x4b,0x6f,0x73};
    static std::uint32_t remainder93      = 2617286099;
    uint256_from_bytes(dividend, dividend93);
    remainder = uint256_div_uint32(quotient, dividend, divisor93);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient93, quotient_data, 32) != 0 || remainder93 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend94[32] = {0x7b,0xc7,0x1d,0xf3,0x8c,0x4c,0xaa,0x83,0x7e,0xe1,0x4b,0x90,0xcb,0x97,0x8b,0xe3,0x08,0x0e,0x31,0xb0,0x34,0x12,0x88,0x22,0x13,0xf3,0x88,0x70,0x4f,0xec,0x0f,0x40};
    static std::uint32_t divisor94     = 1753077011;
    static std::uint8_t  quotient94[32]    = {0x00,0x00,0x00,0x01,0x2f,0x40,0x25,0x7b,0xfa,0x9e,0x6a,0xec,0x02,0x44,0xa4,0x0d,0x52,0x73,0xc1,0xe7,0x2f,0x60,0xc7,0x07,0x57,0xe4,0x44,0xec,0x3e,0x4d,0x60,0xb3};
    static std::uint32_t remainder94      = 1599206135;
    uint256_from_bytes(dividend, dividend94);
    remainder = uint256_div_uint32(quotient, dividend, divisor94);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient94, quotient_data, 32) != 0 || remainder94 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend95[32] = {0x88,0xb4,0x09,0xc8,0xa3,0xa1,0x6d,0x92,0x27,0x90,0xbb,0x01,0x8c,0xd5,0xd1,0x87,0xa9,0xfd,0xa2,0xef,0x65,0x32,0x2a,0x48,0xcb,0xbc,0x6c,0x94,0x19,0xf4,0x8c,0x75};
    static std::uint32_t divisor95     = 2804864265;
    static std::uint8_t  quotient95[32]    = {0x00,0x00,0x00,0x00,0xd1,0x53,0xeb,0x51,0x82,0xab,0x77,0xd5,0xa1,0xa3,0x9a,0x3a,0x4d,0x15,0x84,0x90,0x72,0xf0,0xe1,0x3f,0x8e,0x66,0x5d,0xc6,0xec,0xa2,0xa3,0x37};
    static std::uint32_t remainder95      = 1099828358;
    uint256_from_bytes(dividend, dividend95);
    remainder = uint256_div_uint32(quotient, dividend, divisor95);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient95, quotient_data, 32) != 0 || remainder95 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend96[32] = {0xaa,0xf5,0xa8,0x6e,0x48,0x86,0x6d,0x48,0xfc,0xfd,0x36,0xd1,0x68,0xe7,0xed,0x23,0x45,0x6b,0x31,0x2c,0xb2,0x06,0x1e,0xcc,0x65,0xd4,0x64,0xfd,0x29,0xe7,0x8b,0x06};
    static std::uint32_t divisor96     = 1794632242;
    static std::uint8_t  quotient96[32]    = {0x00,0x00,0x00,0x01,0x99,0x25,0x46,0x72,0x4e,0xa4,0xf6,0x20,0x4a,0x00,0x8c,0xe4,0x43,0x15,0xd2,0x8c,0x42,0x1d,0x29,0x90,0xf5,0x11,0x07,0x5d,0xd9,0xe2,0xe2,0x07};
    static std::uint32_t remainder96      = 1044119464;
    uint256_from_bytes(dividend, dividend96);
    remainder = uint256_div_uint32(quotient, dividend, divisor96);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient96, quotient_data, 32) != 0 || remainder96 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend97[32] = {0x6a,0x01,0x26,0x0f,0x5b,0x70,0x42,0xdf,0xe2,0x39,0xd3,0xd7,0x91,0x07,0x75,0x6f,0xbe,0xce,0x71,0x45,0x4f,0xf6,0xf2,0xc5,0x0d,0x25,0xf9,0x54,0xf4,0x04,0x2f,0x1e};
    static std::uint32_t divisor97     = 78224996;
    static std::uint8_t  quotient97[32]    = {0x00,0x00,0x00,0x16,0xbc,0x35,0x6f,0x8d,0xc7,0x9a,0x59,0xd6,0x0b,0xb8,0xf8,0xaa,0xa8,0xe0,0x92,0x99,0x57,0xe1,0x57,0xbe,0xb8,0x52,0x14,0xaf,0x2b,0x83,0x8d,0x25};
    static std::uint32_t remainder97      = 35075754;
    uint256_from_bytes(dividend, dividend97);
    remainder = uint256_div_uint32(quotient, dividend, divisor97);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient97, quotient_data, 32) != 0 || remainder97 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend98[32] = {0x6c,0x7b,0x31,0xe2,0x28,0x14,0xc4,0x37,0xe6,0xd1,0x43,0x18,0x6f,0x25,0x63,0x0d,0x01,0x81,0x20,0xf8,0xf1,0x26,0x16,0x42,0x34,0x23,0x88,0x0b,0x67,0xac,0x56,0xf8};
    static std::uint32_t divisor98     = 3523456255;
    static std::uint8_t  quotient98[32]    = {0x00,0x00,0x00,0x00,0x84,0x3c,0x18,0x29,0x2d,0xb8,0xae,0xb5,0xea,0x79,0x01,0x24,0x0a,0x45,0x62,0x0e,0xa3,0xc3,0xe6,0x7a,0x82,0x1a,0x6b,0xe4,0xaf,0x1d,0xb2,0x49};
    static std::uint32_t remainder98      = 208909377;
    uint256_from_bytes(dividend, dividend98);
    remainder = uint256_div_uint32(quotient, dividend, divisor98);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient98, quotient_data, 32) != 0 || remainder98 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
    static std::uint8_t  dividend99[32] = {0x29,0x9c,0x85,0x8d,0xc5,0xe6,0xe6,0x2f,0x75,0xfd,0xf3,0x7c,0x5d,0x5e,0xc1,0xad,0xe2,0x01,0xaa,0xfd,0x93,0xea,0x6a,0x94,0x67,0xfd,0xe1,0xc3,0x17,0x2a,0x39,0x0a};
    static std::uint32_t divisor99     = 63713180;
    static std::uint8_t  quotient99[32]    = {0x00,0x00,0x00,0x0a,0xf5,0x10,0xd3,0x51,0x58,0x04,0x99,0x03,0xf9,0xef,0xb7,0x95,0xc0,0x5d,0xca,0x1f,0xcd,0x14,0x44,0xf9,0x63,0xb6,0x99,0x0d,0x55,0x1d,0x3c,0xcd};
    static std::uint32_t remainder99      = 13863198;
    uint256_from_bytes(dividend, dividend99);
    remainder = uint256_div_uint32(quotient, dividend, divisor99);
    uint256_to_bytes(quotient_data, quotient);
    if (std::memcmp(quotient99, quotient_data, 32) != 0 || remainder99 != remainder)
    {
        throw std::runtime_error("err in uint256_div_uint32");
    }
}
